Namespaces | |
namespace | algebra |
Namespace for algebra constructs in Vaucanson. | |
namespace | misc |
The namespace for miscellaneous constructs. | |
namespace | delta_kind |
These are helpers for delta functions: transition or state oriented delta are chosen according to them. | |
Classes | |
struct | dynamic_traits< algebra::AlphabetSetBase< S > > |
Specialization of dynamic_traits for AlphabetSetBase . More... | |
struct | virtual_types< algebra::AlphabetSetBase< S > > |
Specialization of virtual_types for AlphabetSetBase . More... | |
struct | MetaElement< algebra::AlphabetSetBase< S >, T > |
Specialization of MetaElement for AlphabetSetBase . More... | |
struct | dynamic_traits< algebra::FreeMonoidBase< Self > > |
struct | MetaElement< algebra::FreeMonoidBase< Self >, T > |
Element of a free monoid i.e. words. More... | |
struct | dynamic_traits< algebra::FreeMonoidProduct< F, S > > |
Meta information about FreeMonoidProduct. More... | |
struct | MetaElement< algebra::FreeMonoidProduct< F, S >, T > |
Services of an element of a monoid implemented with FreeMonoidProduct. More... | |
struct | dynamic_traits< algebra::FreeMonoidProductBase< Self > > |
struct | MetaElement< algebra::FreeMonoidProductBase< Self >, T > |
Element of a monoid i.e. words. More... | |
struct | dynamic_traits< algebra::MonoidBase< Self > > |
struct | MetaElement< algebra::MonoidBase< Self >, T > |
Defines services of element of every monoid. More... | |
struct | dynamic_traits< algebra::NumericalSemiring > |
Meta information about the NumericalSemiring structural element. More... | |
struct | MetaElement< algebra::NumericalSemiring, T > |
Services of Element for numerical semirings. More... | |
struct | dynamic_traits< algebra::SemigroupBase< Self > > |
struct | MetaElement< algebra::SemigroupBase< Self >, T > |
Services of every element of a semigroup. More... | |
struct | dynamic_traits< algebra::SemiringBase< Self > > |
struct | MetaElement< algebra::SemiringBase< Self >, T > |
Services of every element of semiring (semiring_elt). More... | |
struct | op_star_traits |
Meta information about the return type of the star operation. More... | |
struct | dynamic_traits< algebra::SeriesBase< Self > > |
class | MetaElement< algebra::SeriesBase< Self >, T > |
Services of every series. More... | |
struct | dynamic_traits< algebra::TropicalSemiring< TropicalKind > > |
Meta information about the tropical semirings. More... | |
struct | MetaElement< algebra::TropicalSemiring< TropicalKind >, T > |
Services of element of a tropical semiring. More... | |
struct | MetaElement< algebra::AlphabetSet< L >, std::set< L > > |
Services of every alphabet implemented with std::set. More... | |
struct | dynamic_traits< algebra::AlphabetSet< L > > |
Meta information about AlphabetSet. More... | |
struct | MetaElement< algebra::AlphabetSet< L >, algebra::AlphabetDecorator< L, T > > |
Services of every alphabet implemented with AlphabetDecorator<L, T>. More... | |
struct | dynamic_traits< algebra::FreeMonoid< A > > |
Meta information about FreeMonoid. More... | |
struct | MetaElement< algebra::FreeMonoid< A >, T > |
Services of an element of a free monoid implemented with FreeMonoid. More... | |
struct | MetaElement< algebra::Series< W, M >, T > |
Specialization of MetaElement for series. More... | |
struct | dynamic_traits< algebra::Series< W, M > > |
Dynamic traits for series. More... | |
struct | virtual_types< algebra::Series< W, M > > |
Virtual types for series. More... | |
struct | KRatExpAciCanonical |
Visitor to build a canonical form of an expression, following aci-rules. More... | |
struct | DefaultChooser |
Default chooser for aut_to_exp(). More... | |
struct | RandomChooser |
Choose randomly a state between all currently choosable. More... | |
struct | DMChooser |
Choose a state accordingly to an heuristic. More... | |
class | ListChooser |
Chooser for aut_to_exp(). More... | |
struct | BerrySethiAlgo |
This is the visitor that really computes Berry-Sethi. More... | |
struct | BrzozowskiAlgo |
This is the class that really computes Brzozowski. More... | |
struct | KRatExpInitialDerivation |
Visitor to have an initial set of partial derivatives terms from an expression. More... | |
class | PRatExpDerivationVisitor |
This class performs partial rational expression derivations. More... | |
class | ConstantTermEval |
This is the visitor that really computes the constant term. More... | |
struct | KRatExpFlatten |
struct | linearize_element |
The types of a linearized expression. More... | |
struct | FindBestSearch |
Specific implementation for search(). More... | |
struct | WindowedBackSearch |
Specific implementation for search(). More... | |
struct | dynamic_traits< Automata< Series, Kind > > |
Dynamic traits for automata. More... | |
struct | MetaElement< Automata< Series, Kind >, T > |
MetaElement specialization for automata. More... | |
struct | virtual_types< Automata< Series, Kind > > |
Virtual types for automata. More... | |
class | Automata |
Final class for the set of automata. More... | |
struct | AutomataBase |
The most general concept of automaton. More... | |
struct | MetaElement< AutomataBase< Self >, T > |
Services of every element of the automata set. More... | |
class | AutoKind< labels_are_series, Self, Series, SeriesT, LabelT > |
Add adapted accessors in function of the automaton kind. More... | |
struct | dynamic_traits< Transducer< Series, Kind > > |
Dynamic traits for transducers. More... | |
struct | MetaElement< Transducer< Series, Kind >, T > |
Specialization of MetaElement for transducers. More... | |
struct | virtual_types< Transducer< Series, Kind > > |
Virtual types for transducers. More... | |
class | Transducer |
Final class for the set of transducers. More... | |
struct | TransducerBase |
The most general concept of transducer. More... | |
struct | transducer_traits |
Traits for transducer implementation. More... | |
struct | MetaElement< TransducerBase< Self >, T > |
Services of every element of the transducer set. More... | |
struct | geometry |
Store 4 maps for geometry properties of the automaton. More... | |
struct | TransposeView |
Provides a transposed view of an automaton. More... | |
struct | transpose_traits |
Traits for TransposeView. More... | |
struct | automaton_traits< TransposeView< T > > |
automaton_traits specialization for the TransposeView implementation. More... | |
class | Element |
Glue class between structural elements and implementation values. More... | |
struct | op_add_traits |
The type of the result of addition between two Element instances. More... | |
struct | op_sub_traits |
The type of the result of substraction between two Element instances. More... | |
struct | op_mul_traits |
The type of the result of multiplication between two Element instances. More... | |
struct | op_div_traits |
The type of the result of division between two Element instances. More... | |
struct | op_mod_traits |
The type of the result of modulus between two Element instances. More... | |
struct | MetaElement< Structure< S >, T > |
The base class that glues structural elements to implementation values. More... | |
struct | SetSlotAttribute |
Base class for SetSlot . More... | |
struct | SetSlotAttribute< S, true > |
Base class for SetSlot , specializing SetSlotAttribute . More... | |
struct | SetSlot |
Type of the set_ attribute of the Element class. More... | |
struct | Structure |
Base class for the hierarchy of structural element types. More... | |
struct | dynamic_traits< Structure< S > > |
Specialization of dynamic_traits for Structure . More... | |
struct | virtual_types< Structure< S > > |
Specialization of virtual_types for Structure . More... | |
struct | SyntacticDecorator |
Provides the standard operator delegations to Element. More... | |
Enumerations | |
enum | op_choose_max_word_length_t |
Maximum length of words generated by op_choose. More... | |
Functions | |
template<typename S , typename T > | |
std::pair< bool, typename Element< S, T >::letter_t > | parse_letter (const Element< S, T > &alphabet, const std::string &s) |
Public interface to the letter parser. | |
template<typename S , typename T > | |
Element< S, T > | mirror (const Element< S, T > &e) |
Return a fresh word that is the mirror. | |
template<typename S , typename T > | |
std::pair< bool, int > | parse_word (Element< S, T > &dest, const std::string &s) |
Parse the beginning of the string looking for a word. | |
template<typename S , typename T > | |
op_star_traits< S, T >::ret_t | star (const Element< S, T > &w) |
Returns a fresh weight that is the star of w. | |
template<typename S , typename T > | |
bool | parse_weight (Element< S, T > &w, const std::string &, typename std::string::const_iterator &) |
Parse the beginning of the string looking for a weight. | |
template<typename S , typename T > | |
bool | starable (const Element< S, T > &elt) |
Returns true if we can compute the star of the weight. | |
template<typename S , typename T > | |
Element< S, T > | transpose (const algebra::SeriesBase< S > &s, const T &t) |
returns a fresh series that is the transposed of the argument. | |
template<typename S , typename T > | |
bool | is_support_in_alphabet (const Element< S, T > &s) |
Returns true if the support of the series is only composed of letters. | |
template<typename S1 , typename S2 , typename T1 , typename T2 > | |
void | extract_support (Element< S1, T1 > &, Element< S2, T2 > &) |
Make the first series be the support of the second. | |
template<class S , class T > | |
Element< S, T > | hadamard (const Element< S, T > &lhs, const Element< S, T > &rhs) |
Return the hadamard product of lhs and rhs. | |
template<typename A , typename AI > | |
std::set< typename Element< A, AI >::hstate_t > | accessible_states (const Element< A, AI > &a) |
Return accessible states. | |
template<typename A , typename AI > | |
Element< A, AI > | accessible (const Element< A, AI > &a) |
Extract the sub-automaton composed of accessible states. | |
template<typename A , typename AI > | |
void | accessible_here (Element< A, AI > &a) |
In-place extract the sub-automaton of accessible states. | |
template<typename A , typename AI > | |
std::set< typename Element< A, AI >::hstate_t > | coaccessible_states (const Element< A, AI > &a) |
Return co-accessible states. | |
template<typename A , typename AI > | |
Element< A, AI > | coaccessible (const Element< A, AI > &a) |
Extract the sub-automaton composed of co-accessible states. | |
template<typename A , typename AI > | |
void | coaccessible_here (Element< A, AI > &a) |
In-place extract the sub-automaton of co-accessible states. | |
template<typename S , typename SI > | |
Element< S, SI > | canonical (const Element< S, SI > &exp) |
Transform a krat expression into a canonical form using only ACI-rules. | |
template<typename A , typename AI > | |
Element< A, AI >::series_set_elt_t | aut_to_exp (const Element< A, AI > &a) |
Returns a series which describes the language of the automaton. | |
template<typename A , typename AI , typename Chooser > | |
Element< A, AI >::series_set_elt_t | aut_to_exp (const Element< A, AI > &a, const Chooser &c) |
Returns a series which describes the language of the automaton. | |
template<typename A , typename T , typename Exp > | |
void | berry_sethi (Element< A, T > &, const Exp &) |
Build an automaton from an expression using the Berry-Sethi construction. | |
template<typename S , typename T > | |
linearize_element< S, T > ::alphabet_t | linearized_alphabet (const Element< S, T > &exp) |
Computes a linearized alphabet from a rational expression. | |
template<typename Exp , typename Letter > | |
Exp | linear_exp_continuation (const Exp &exp, const Letter &l) |
This function computes a continuation on linearized expressions. | |
template<typename A , typename T , typename Exp > | |
void | brzozowski (Element< A, T > &, const Exp &) |
Build an automaton from an expression using the Brzozowski construction. | |
template<typename A , typename AI > | |
void | complement_here (Element< A, AI > &a) |
Complement in place the set of final states. | |
template<typename A , typename AI > | |
Element< A, AI > | complement (const Element< A, AI > &a) |
Complement the set of final states. | |
template<typename A , typename AI > | |
void | complete_here (Element< A, AI > &a) |
Make the transition function of an automaton total w.r.t. | |
template<typename A , typename AI > | |
Element< A, AI > | complete (const Element< A, AI > &a) |
Make the transition function of an automaton total w.r.t. | |
template<typename A , typename AI > | |
bool | is_complete (const Element< A, AI > &a) |
Test whether an automaton is complete. | |
template<typename S , typename T > | |
Element< S, T > | composition_cover (const Element< S, T > &fmp) |
Facade for composition cover. | |
template<typename S , typename T > | |
Element< S, T > | composition_co_cover (const Element< S, T > &fmp) |
Facade for composition co-cover. | |
template<typename A , typename AI > | |
Element< A, AI > | concatenate (const Element< A, AI > &lhs, const Element< A, AI > &rhs) |
Return the concatenation of two automata. | |
template<typename A , typename AI > | |
void | concatenate_here (Element< A, AI > &lhs, const Element< A, AI > &rhs) |
In place concatenation of two automata. | |
template<typename A , typename AI > | |
bool | is_cut_up (const Element< A, AI > &a) |
Check if labels are series with one element. | |
template<typename A , typename AI > | |
Element< A, AI > | cut_up (const Element< A, AI > &a) |
Transform an automaton labeled with series to an automaton where all labels are series with one and only one element. | |
template<typename A , typename AI > | |
void | cut_up (const Element< A, AI > &a, Element< A, AI > &res) |
Transform an automaton labeled with series to an automaton where all labels are series with one and only one element. | |
template<typename A , typename AI > | |
void | cut_up_here (Element< A, AI > &a) |
Transform an automaton labeled with series to an automaton where all labels are series with one and only one element. | |
template<typename A , typename T , typename Exp > | |
void | derived_term_automaton (Element< A, T > &a, const Exp &e) |
Convert a krat expression into an automaton using derivatives. | |
template<typename A , typename T , typename Exp > | |
Element< A, T > | derived_term_automaton (const Exp &e) |
Convert a krat expression into an automaton using derivatives. | |
template<typename A , typename T , typename Exp > | |
Element< A, T > | broken_derived_term_automaton (const Exp &e) |
Convert a krat expression into an automaton using derivatives. | |
template<typename A , typename AI > | |
void | eps_removal_here (Element< A, AI > &a, misc::direction_type dir=misc::backward) |
In place eps_removal of an automaton (default is backward eps_removal). | |
template<typename A , typename AI > | |
Element< A, AI > | eps_removal (const Element< A, AI > &a, misc::direction_type dir=misc::backward) |
Eps_Removal of an automaton (default is backward eps_removal). | |
template<typename A , typename AI > | |
void | backward_eps_removal_here (Element< A, AI > &a) |
In place backward eps_removal of an automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | backward_eps_removal (const Element< A, AI > &a) |
Backward eps_removal of an automaton. | |
template<typename A , typename AI > | |
void | forward_eps_removal_here (Element< A, AI > &a) |
In place forward eps_removal of an automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | forward_eps_removal (const Element< A, AI > &a) |
Forward eps_removal of an automaton. | |
template<typename A , typename AI > | |
void | eps_removal_here_sp (Element< A, AI > &a, misc::direction_type dir=misc::backward) |
In place eps_removal_sp of an automaton (default is backward eps_removal). | |
template<typename A , typename AI > | |
Element< A, AI > | eps_removal_sp (const Element< A, AI > &a, misc::direction_type dir=misc::backward) |
Eps_Removal of an automaton (default is backward eps_removal). | |
template<typename A , typename AI > | |
void | backward_eps_removal_here_sp (Element< A, AI > &a) |
In place backward eps_removal_sp of an automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | backward_eps_removal_sp (const Element< A, AI > &a) |
Backward eps_removal_sp of an automaton. | |
template<typename A , typename AI > | |
void | forward_eps_removal_here_sp (Element< A, AI > &a) |
In place forward eps_removal_sp of an automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | forward_eps_removal_sp (const Element< A, AI > &a) |
Forward eps_removal_sp of an automaton. | |
template<typename S , typename A , typename B > | |
bool | are_equivalent (const Element< S, A > &a, const Element< S, B > &b) |
Returns true iff the two boolean automata are equivalents, i.e., if they recognize the same language. | |
template<typename A , typename AI , typename W > | |
Element< A, AI >::semiring_elt_t | eval (const Element< A, AI > &a, const W &word) |
Return the image of a word by an automaton. | |
template<typename ST , typename TT > | |
void | evaluation_fmp (const Element< ST, TT > &, const typename input_projection_helper< ST, TT >::ret &, typename output_projection_helper< ST, TT >::ret &) |
Evaluation over normalized and sub-normalized transducers, seen as automata over a free monoid product. | |
template<typename SA , typename TA , typename ST , typename TT , typename SRET , typename TRET > | |
void | evaluation_rw (const Element< SA, TA > &a, const Element< ST, TT > &t, Element< SRET, TRET > &ret) |
Evaluate for a "letterized" automaton and a realtime transducer. | |
template<typename S , typename K , typename T > | |
identity_transducer_helper< S, K, T >::ret | extension (const Element< S, T > &) |
Extend an automaton to a transducer. | |
template<typename SA , typename TA , typename ST , typename TT > | |
Element< ST, TT > | extension (const Element< SA, TA > &, const Element< ST, TT > &) |
Extend an automaton to a transducer. | |
template<typename S , typename T , typename Ss , typename Ts > | |
void | finite_support_convert (Element< S, T > &dst, const Element< Ss, Ts > &org) |
Finite support conversion. | |
template<class S , class T > | |
output_projection_helper< S, T > ::ret | image (const Element< S, T > &) |
template<typename SA , typename TA , typename M > | |
void | partial_elimination (const Element< SA, TA > &a, M &state_exp_pair) |
This function computes a set of expression, after having eliminated all states which are not initial or final. | |
template<typename S1 , typename T1 , typename S2 , typename T2 , typename M > | |
void | partial_evaluation (const Element< S1, T1 > &E, const Element< S2, T2 > &S, const typename Element< S2, T2 >::hstate_t &p, M &res) |
Partial evaluation of a K RatExp E over a realtime transducer S, starting from a given state p. | |
template<typename A , typename T > | |
bool | has_successors (const Element< A, T > &a, const typename automaton_traits< T >::hstate_t s) |
Whether a state has successors. | |
template<typename A , typename T > | |
bool | has_predecessors (const Element< A, T > &a, const typename automaton_traits< T >::hstate_t s) |
Whether a state has predecessors. | |
template<typename A , typename T > | |
void | invert (const Element< A, T > &t, Element< A, T > &res) |
Invert a transducer. | |
template<typename A , typename T > | |
Element< A, T > & | invert (const Element< A, T > &t) |
Invert a transducer. | |
template<typename A , typename AI > | |
bool | is_ambiguous (const Element< A, AI > &aut) |
Test the ambiguity of automaton. | |
template<typename A , typename AI > | |
bool | is_deterministic (const Element< A, AI > &a) |
Test if an automaton is deterministic. | |
template<typename A , typename AI > | |
bool | is_empty (const Element< A, AI > &a) |
Evaluate if an automaton is empty. | |
template<typename S , typename A > | |
bool | is_ltl (const Element< S, A > &t) |
Test whether an FMP transducer is letter-to-letter. | |
template<typename S , typename A > | |
bool | is_normalized_transducer (const Element< S, A > &t) |
Test the normalization of transducer. | |
template<typename A , typename AI > | |
bool | is_useless (const Element< A, AI > &a) |
Return true if the automaton has no successful computation. | |
template<typename A , typename T > | |
bool | are_isomorphic (const Element< A, T > &a, const Element< A, T > &b) |
Returns true if the two automata are isomorphic. | |
template<class Series , class T , class Letter > | |
Element< Series, T > | cderivate (const Element< Series, T > &exp, Letter a) |
The c-derivative of the krat expression w.r.t to a letter. | |
template<class Series , class T , class Word > | |
Element< Series, T > | word_cderivate (const Element< Series, T > &exp, Word a) |
The c-derivative of the krat expression w.r.t to a word. | |
template<class Series , class T > | |
std::pair< typename Element < Series, T >::semiring_elt_t, bool > | constant_term (const Element< Series, T > &exp) |
Return the constant term of the krat expression. | |
template<class Series , class T , class Letter > | |
std::pair< Element< Series, T > , bool > | derivate (const Element< Series, T > &exp, Letter a) |
The antimirov derivative of the krat expression w.r.t to a letter. | |
template<class Series , class T , class Word > | |
std::pair< Element< Series, T > , bool > | word_derivate (const Element< Series, T > &exp, Word a) |
The antimirov derivative of the krat expression w.r.t to a word. | |
template<class Series , class T > | |
std::list< typename Series::monoid_t::alphabet_t::letter_t > | flatten (const Element< Series, T > &exp) |
This algorithm extracts the letters from a rational expression. | |
template<class Series , class T > | |
linearize_element< Series, T > ::element_t | linearize (const Element< Series, T > &exp) |
The linearization of the krat expression. | |
template<class Series , class T , class Letter > | |
std::pair< std::set< Element < Series, T > >, bool > | partial_derivate (const Element< Series, T > &exp, Letter a) |
The partial derivative of the krat expression w.r.t to a letter. | |
template<class S , class T > | |
Element< S, T > | letter_to_letter_composition (const Element< S, T > &lhs, const Element< S, T > &rhs) |
Undocumented. | |
template<typename A , typename AI > | |
Element< A, AI > | minimization_hopcroft (const Element< A, AI > &a) |
Return the minimal automaton using the hopcroft algorithm. | |
template<typename A , typename AI > | |
Element< A, AI > | quotient (const Element< A, AI > &a) |
Return the quotient of a non-deterministic acceptor. | |
template<typename A , typename AI > | |
Element< A, AI > | minimization_moore (const Element< A, AI > &a) |
Returns the minimal deterministic automaton associated to the input one. | |
template<typename A , typename AI > | |
Element< A, AI > | co_minimization_moore (const Element< A, AI > &a) |
Returns the co-minimal co-deterministic automaton associated to the input one. | |
template<typename A , typename AI > | |
void | minimization_moore_here (Element< A, AI > &a) |
Minimalize the deterministic input automaton. | |
template<typename A , typename AI > | |
void | co_minimization_moore_here (Element< A, AI > &a) |
Co-minimalize the co-deterministic input automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | normalize (const Element< A, AI > &a) |
Return the fresh thompson-normalized automaton. | |
template<typename A , typename AI > | |
void | normalize_here (Element< A, AI > &a) |
In-place normalize to the thompson form. | |
template<typename A , typename AI > | |
bool | is_normalized (const Element< A, AI > &a) |
Return true if the input automaton is thompson-normalized. | |
template<typename A , typename AI1 , typename AI2 > | |
void | union_of_normalized_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Do the in-place union of two thompson-normalized automata. | |
template<typename A , typename AI1 , typename AI2 > | |
Element< A, AI1 > | union_of_normalized (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Return the fresh union of two thompson-normalized automata. | |
template<typename A , typename AI1 , typename AI2 > | |
void | concatenate_of_normalized_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Do the in-place concatenation of two thompson-normalized automata. | |
template<typename A , typename AI1 , typename AI2 > | |
Element< A, AI1 > | concatenate_of_normalized (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Return the fresh concatenation of two thompson-normalized automata. | |
template<typename A , typename AI > | |
void | star_of_normalized_here (Element< A, AI > &a) |
Do in-place star transformation on the thompson-normalized input. | |
template<typename A , typename AI > | |
Element< A, AI > | star_of_normalized (const Element< A, AI > &a) |
Return the fresh star transformation of its normalized input. | |
template<typename S , typename T > | |
void | compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret) |
Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product. | |
template<typename S , typename T > | |
Element< S, T > | compose (const Element< S, T > &lhs, const Element< S, T > &rhs) |
Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product. | |
template<typename S , typename T > | |
void | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret) |
Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product. | |
template<typename S , typename T > | |
Element< S, T > | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs) |
Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product. | |
template<typename S , typename M1 , typename M2 , typename lhs_t , typename rhs_t , typename res_t > | |
void | do_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret) |
Ambiguous composition. | |
template<typename S , typename M1 , typename M2 , typename lhs_t , typename rhs_t , typename res_t > | |
void | do_u_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret) |
Unambiguous composition. | |
template<typename auto_t , typename trans_t > | |
void | set_states (const trans_t &, auto_t &, std::map< typename trans_t::hstate_t, typename auto_t::hstate_t > &) |
template<typename A , typename AI > | |
void | realtime_here (Element< A, AI > &a, misc::direction_type dir) |
Modify an automaton in place to make it realtime. | |
template<typename A , typename AI > | |
Element< A, AI > | realtime (const Element< A, AI > &a, misc::direction_type dir) |
Create a realtime automaton from another one. | |
template<typename S , typename T > | |
Element< S, T > | realtime (const Element< S, T > &e) |
Compute the realtime version of a rational expression or an automata. | |
template<typename S , typename T > | |
void | realtime_here (Element< S, T > &e) |
Modify a rational expression or automata in place to make it realtime. | |
template<typename S , typename T > | |
bool | is_realtime (const Element< S, T > &e) |
Test whether an automaton or a rational expression is realtime. | |
template<typename A , typename AI > | |
Element< A, AI > | reduce (const Element< A, AI > &a, misc::direction_type dir=misc::right_left) |
Reduce of an automaton (default right_left). | |
template<typename A , typename AI > | |
void | reduce_here (Element< A, AI > &a, misc::direction_type dir=misc::right_left) |
In place reduce of an automaton (default right_left). | |
template<typename S , typename T > | |
void | rw_composition (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret) |
Composition for Rational-Weight transducers. | |
template<typename S , typename T > | |
Element< S, T > | rw_composition (const Element< S, T > &lhs, const Element< S, T > &rhs) |
Composition for Rational-Weight transducers. | |
template<typename InputIterator , typename FoundFunctor , typename Series , typename Kind , typename T > | |
void | search (const Element< Automata< Series, Kind >, T > &a, const InputIterator &begin, const InputIterator &end, typename Element< Automata< Series, Kind >, T >::letter_t eol, FoundFunctor &f) |
Search for a rational expression into a text. | |
template<typename Series , typename Kind , typename T , typename StatesSet > | |
static unsigned int | compute_distances (const Element< Automata< Series, Kind >, T > &a, std::vector< StatesSet > &distances) |
Compute distances from initial states to final states. | |
template<typename InputIterator , typename Series , typename Kind , typename T , typename StatesSet > | |
static std::pair< bool, unsigned int > | window_backsearch (const misc::Window< InputIterator, typename Element< Automata< Series, Kind >, T >::letter_t > &w, const Element< Automata< Series, Kind >, T > &a, const std::vector< StatesSet > &distances) |
Back search inside a window. | |
template<typename InputIterator , typename FoundFunctor , typename Series , typename Kind , typename T > | |
static InputIterator | confirm_and_report_match (const misc::Window< InputIterator, typename Element< Automata< Series, Kind >, T >::letter_t > &w, const Element< Automata< Series, Kind >, T > &a, FoundFunctor &f) |
Finds the longest match of a starting from w, and report it to the functor. | |
template<typename A , typename AI > | |
void | standardize (Element< A, AI > &a) |
Returns a standard automaton associated to the input. | |
template<typename A , typename AI > | |
bool | is_standard (const Element< A, AI > &a) |
Returns true if the input automaton is standard. | |
template<typename A , typename AI1 , typename AI2 > | |
void | union_of_standard_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
In-place union of two standard automata. | |
template<typename A , typename AI1 , typename AI2 > | |
Element< A, AI1 > | union_of_standard (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Return a fresh union of two standard automata. | |
template<typename A , typename AI1 , typename AI2 > | |
void | concat_of_standard_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
In-place concatenation of two standard automata. | |
template<typename A , typename AI1 , typename AI2 > | |
Element< A, AI1 > | concat_of_standard (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Return a fresh concatenation of two standard automata. | |
template<typename A , typename AI > | |
void | star_of_standard_here (Element< A, AI > &a) |
In-place star transformation of a standard automata. | |
template<typename A , typename AI > | |
Element< A, AI > | star_of_standard (const Element< A, AI > &a) |
Return the fresh star transformation of a standard automata. | |
template<typename A , typename T , typename Exp > | |
void | standard_of (Element< A, T > &a, const Exp &e) |
Convert a rational expression into a standard automaton. | |
template<typename A , typename AI , typename HStatesSet > | |
Element< A, AI > | sub_automaton (const Element< A, AI > &a, const HStatesSet &s, bool check_states=true) |
Returns a fresh automaton that is the sub-automaton defined by a set. | |
template<typename A , typename AI , typename HStatesSet > | |
void | sub_automaton_here (Element< A, AI > &a, const HStatesSet &s, bool check_states=true) |
Select a sub-automaton into a given automaton. | |
template<class S , class T > | |
Element< S, T > | sub_normalize (const Element< S, T > &a) |
Sub-normalize a FMP transducer. | |
template<class S , class T1 , class T2 > | |
void | sub_normalize (const Element< S, T1 > &a, Element< S, T2 > &res) |
Sub-normalize a FMP transducer. | |
template<class S , class T > | |
void | sub_normalize_here (Element< S, T > &a) |
Sub-normalize a FMP transducer, in place version. | |
template<class S , class T > | |
bool | is_sub_normalized (const Element< S, T > &a) |
Check if a FMP transducer is sub-normalized. | |
template<typename A , typename AI1 , typename AI2 > | |
void | sum_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
In place summing of two automata. | |
template<typename A , typename AI1 , typename AI2 > | |
Element< A, AI1 > | sum (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs) |
Summing of two automata. | |
template<typename A , typename T , typename Letter , typename Weight > | |
void | thompson_of (Element< A, T > &out, const rat::exp< Letter, Weight > &kexp) |
The Thompson automaton associated to the krat expression. | |
template<typename AutoType , typename S , typename K , class T > | |
Element< Automata< S, K > , AutoType > | thompson_of (const Element< S, T > &exp) |
The Thompson automaton associated to the krat expression. | |
template<typename A , typename AI1 , typename AI2 > | |
void | transpose (Element< A, AI1 > &dst, const Element< A, AI2 > &src) |
Transposition of an automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | transpose (const Element< A, AI > &src) |
Return a fresh transposed automaton. | |
template<typename A , typename AI > | |
std::set< typename Element< A, AI >::hstate_t > | useful_states (const Element< A, AI > &a) |
Returns a useful states of the automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | trim (const Element< A, AI > &a) |
Return a fresh automaton in which non useful states are removed. | |
template<typename A , typename AI > | |
void | trim_here (Element< A, AI > &a) |
Trim a. | |
template<typename lhs_t , typename rhs_t , typename F > | |
void | auto_translate_transitions (lhs_t &dst, const rhs_t &from, const F &translate_fun) |
template<typename S , typename T > | |
bool | op_contains (const Structure< S > &set, const T &value) |
Check whether a value is contained in a set. | |
template<typename S , typename T , typename U > | |
bool | op_eq (const Structure< S > &, const T &v1, const U &v2) |
Equality between two structured values. | |
template<typename S , typename V , typename T , typename U > | |
bool | op_eq (const Structure< S > &, const Structure< V > &, const T &v1, const U &v2) |
Equality between two structured values. | |
template<typename S , typename T , typename U > | |
bool | op_lt (const Structure< S > &, const T &v1, const U &v2) |
Ordered comparison between two structured values. | |
template<typename S , typename V , typename T , typename U > | |
bool | op_lt (const Structure< S > &, const Structure< V > &, const T &v1, const U &v2) |
Ordered comparison between two structured values. | |
template<typename S , typename R , typename T > | |
R | op_convert (const Structure< S > &se, SELECTOR(R), const T &data) |
Default conversion between value types with computation. | |
template<typename S , typename T > | |
const T & | op_convert (const Structure< S > &se, SELECTOR(T), const T &from_data) |
Pass-through conversion. | |
template<typename S , typename T > | |
const T & | op_convert (const Structure< S > &se, SELECTOR(T), const Structure< S > &from_se, const T &from_data) |
Pass-through conversion between compatible structures. | |
template<typename S , typename T > | |
T | op_default (const Structure< S > &se, SELECTOR(T)) |
Default construction of values using Structure . | |
template<typename S , typename T > | |
void | op_swap (const Structure< S > &se, T &v1, T &v2) |
Default swap operator. | |
template<typename S , typename T , typename U > | |
void | op_assign (const Structure< S > &s, T &dst, const U &src) |
Assignement operator between two implementations of a Structure<S>. | |
template<typename S , typename T , typename U > | |
void | op_assign (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &src) |
Assignement operator between two implementations of two differents structures. | |
template<typename S , typename T , typename U > | |
void | op_in_add (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
Addition in place operator between two different elements. | |
template<typename S , typename T , typename U > | |
void | op_in_sub (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
Substraction in place operator between two different elements. | |
template<typename S , typename T , typename U > | |
void | op_in_mul (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
Multiplication in place operator between two different elements. | |
template<typename S , typename T , typename U > | |
void | op_in_div (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
Division in place operator between two different elements. | |
template<typename S , typename T , typename U > | |
void | op_in_mod (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
Modulo in place operator between two different elements. | |
template<typename S , typename T , typename U > | |
T | op_add (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
Addition operator between two different elements. | |
template<typename S , typename T , typename U > | |
T | op_sub (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
Substraction operator between two different elements. | |
template<typename S , typename T , typename U > | |
T | op_mul (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
Multiplication operator between two different elements. | |
template<typename S , typename T , typename U > | |
T | op_div (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
Division operator between two different elements. | |
template<typename S , typename T , typename U > | |
T | op_mod (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
Modulo operator between two different elements. | |
template<typename S , typename St , typename T > | |
St & | op_rin (const Structure< S > &s, St &st, const T &v) |
Input stream operator. | |
template<typename S , typename St , typename T > | |
St & | op_rout (const Structure< S > &s, St &st, const T &v) |
Output stream operator. | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static bool | operator< (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Comparison between Element instances. | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static bool | operator> (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Comparison between Element instances. | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static bool | operator<= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Comparison between Element instances. | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static bool | operator>= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Comparison between Element instances. | |
template<typename S , typename T , typename U > | |
static bool | operator< (const vcsn::Element< S, T > &e, const U &v) |
Comparison between Element and foreign values (left version). | |
template<typename S , typename T , typename U > | |
static bool | operator> (const vcsn::Element< S, T > &e, const U &v) |
Comparison between Element and foreign values (left version). | |
template<typename S , typename T , typename U > | |
static bool | operator>= (const vcsn::Element< S, T > &e, const U &v) |
Comparison between Element and foreign values (left version). | |
template<typename S , typename T , typename U > | |
static bool | operator<= (const vcsn::Element< S, T > &e, const U &v) |
Comparison between Element and foreign values (left version). | |
template<typename U , typename S , typename T > | |
static bool | operator< (const U &v, const vcsn::Element< S, T > &e) |
Comparison between Element and foreign values (right version). | |
template<typename U , typename S , typename T > | |
static bool | operator> (const U &v, const vcsn::Element< S, T > &e) |
Comparison between Element and foreign values (right version). | |
template<typename U , typename S , typename T > | |
static bool | operator>= (const U &v, const vcsn::Element< S, T > &e) |
Comparison between Element and foreign values (right version). | |
template<typename U , typename S , typename T > | |
static bool | operator<= (const U &v, const vcsn::Element< S, T > &e) |
Comparison between Element and foreign values (right version). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static bool | operator== (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Equality between Element instances. | |
template<typename S , typename T , typename U > | |
static bool | operator== (const vcsn::Element< S, T > &e, const U &v) |
Equality between Element and foreign values (left version). | |
template<typename U , typename S , typename T > | |
static bool | operator== (const U &v, const vcsn::Element< S, T > &e) |
Equality between Element and foreign values (right version). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static bool | operator!= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Difference between Element instances. | |
template<typename S , typename T , typename U > | |
static bool | operator!= (const vcsn::Element< S, T > &e, const U &v) |
Difference between Element and foreign values (left version). | |
template<typename U , typename S , typename T > | |
static bool | operator!= (const U &v, const vcsn::Element< S, T > &e) |
Difference between Element and foreign values (right version). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static vcsn::op_add_traits< S1, S2, T1, T2 >::ret_t | operator+ (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Addition between Element instances. | |
template<typename S , typename T , typename U > | |
static vcsn::Element< S, T > | operator+ (const vcsn::Element< S, T > &e, const U &v) |
Addition between Element and foreign values (left). | |
template<typename U , typename S , typename T > | |
static vcsn::Element< S, T > | operator+ (const U &v, const vcsn::Element< S, T > &e) |
Addition between Element and foreign values (right). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static vcsn::op_sub_traits< S1, S2, T1, T2 >::ret_t | operator- (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Substraction between Element instances. | |
template<typename S , typename T , typename U > | |
static vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &e, const U &v) |
Substraction between Element and foreign values (left). | |
template<typename U , typename S , typename T > | |
static vcsn::Element< S, T > | operator- (const U &v, const vcsn::Element< S, T > &e) |
Substraction between Element and foreign values (right). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static vcsn::op_mul_traits< S1, S2, T1, T2 >::ret_t | operator* (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Multiplication between Element instances. | |
template<typename S , typename T , typename U > | |
static vcsn::Element< S, T > | operator* (const vcsn::Element< S, T > &e, const U &v) |
Multiplication between Element and foreign values (left). | |
template<typename U , typename S , typename T > | |
static vcsn::Element< S, T > | operator* (const U &v, const vcsn::Element< S, T > &e) |
Multiplication between Element and foreign values (right). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static vcsn::op_div_traits< S1, S2, T1, T2 >::ret_t | operator/ (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Division between Element instances. | |
template<typename S , typename T , typename U > | |
static vcsn::Element< S, T > | operator/ (const vcsn::Element< S, T > &e, const U &v) |
Division between Element and foreign values (left). | |
template<typename U , typename S , typename T > | |
static vcsn::Element< S, T > | operator/ (const U &v, const vcsn::Element< S, T > &e) |
Division between Element and foreign values (right). | |
template<typename S1 , typename T1 , typename S2 , typename T2 > | |
static vcsn::op_mod_traits< S1, S2, T1, T2 >::ret_t | operator% (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2) |
Modulus between Element instances. | |
template<typename S , typename T , typename U > | |
static vcsn::Element< S, T > | operator% (const vcsn::Element< S, T > &e, const U &v) |
Modulus between Element and foreign values (left). | |
template<typename U , typename S , typename T > | |
static vcsn::Element< S, T > | operator% (const U &v, const vcsn::Element< S, T > &e) |
Modulus between Element and foreign values (right. | |
template<typename S , typename T > | |
static vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &) |
Unary negation of Element instances. | |
template<typename St , typename S , typename T > | |
static St & | operator<< (St &s, const vcsn::Element< S, T > &e) |
Output to stream. | |
template<typename St , typename S , typename T > | |
static St & | operator>> (St &s, const vcsn::Element< S, T > &e) |
Input from stream. | |
Determinization algorithms | |
template<typename A , typename AI > | |
Element< A, AI > | determinize (const Element< A, AI > &a) |
Build a deterministic automaton from a Boolean automaton. | |
template<typename A , typename AI > | |
Element< A, AI > | determinize (const Element< A, AI > &a, std::map< typename Element< A, AI >::hstate_t, std::set< typename Element< A, AI >::hstate_t > > &m) |
Build a deterministic automaton from a Boolean automaton, keeping trace of state-to-states correspondences. | |
FMP automaton to rational weight transducer algorithm. | |
Compute the equivalent Rational Weight transducer of a FMP automaton. Please note that for the moment this function works only if the support of each transition is finite.
Algorithm : If the FMP contains transitions with "complex" expression (E), i.e. infinite support, then Thompson of E. With the resulting automaton apply a conversion. i.e. (a,x) -> a|x | |
template<typename S , typename T , typename SS , typename TT > | |
Element< SS, TT > & | fmp_to_rw (const Element< S, T > &fmp, Element< SS, TT > &res) |
Letter-to-letter FMP automaton to pair letter automaton algorithm. | |
Compute the pair letter automaton associated to an ltl FMP automaton. | |
template<typename S , typename T > | |
void | ltl_to_pair (const Element< S, T > <l, typename mute_ltl_to_pair< S, T >::ret &res) |
template<typename S , typename T > | |
mute_ltl_to_pair< S, T >::ret | ltl_to_pair (const Element< S, T > <l) |
Pair letter automaton to FMP transducer algorithm. | |
Compute the FMP transducer associated to a pair letter automaton. | |
template<typename S , typename T > | |
void | pair_to_fmp (const Element< S, T > &aut, typename mute_pair_to_fmp< S, T >::ret &res) |
template<typename S , typename T > | |
mute_pair_to_fmp< S, T >::ret | pair_to_fmp (const Element< S, T > &aut) |
Product algorithm | |
Returns a fresh automaton that is the product of the two input ones.
| |
template<typename A , typename T , typename U > | |
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, const bool use_geometry=false) |
template<typename A , typename T , typename U > | |
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< typename T::hstate_t, std::pair< typename T::hstate_t, typename U::hstate_t > > &, const bool use_geometry=false) |
Rational Weight transducer to FMP automaton conversion | |
template<typename S , typename T , typename SS , typename TT > | |
Element< SS, TT > & | rw_to_fmp (const Element< S, T > &trans, Element< SS, TT > &res) |
Compute the equivalent FMP automaton of a Rational Weight transducer. | |
Default operation on automata. | |
template<typename S , typename R , typename T > | |
R | op_convert (const AutomataBase< S > &se, SELECTOR(R), const T &data) |
Default conversion between value types with computation. | |
template<typename S , typename T > | |
const T & | op_convert (const AutomataBase< S > &, SELECTOR(T), const T &from_data) |
Default conversion between value types with computation. | |
template<typename S , typename T , typename U > | |
void | op_assign (const AutomataBase< S > &s, T &dst, const U &src) |
Assignement operator between two implementations of a Structure<S>. | |
template<typename S , typename T > | |
void | op_assign (const AutomataBase< S > &concept, T &dst, const T &src) |
Default conversion between value types with computation. | |
template<class S , class T > | |
const automaton_traits< T > ::tag_t & | op_get_tag (const AutomataBase< S > &, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::tag_t & | op_get_tag (const AutomataBase< S > &, T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
const automaton_traits< T > ::geometry_t & | op_get_geometry (const AutomataBase< S > &, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::geometry_t & | op_get_geometry (const AutomataBase< S > &, T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_exists (const AutomataBase< S > &s, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::states_t | op_states (const AutomataBase< S > &, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_get_state (const AutomataBase< S > &, const T &, int state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::transitions_t | op_transitions (const AutomataBase< S > &, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::initial_support_t | op_initial (const AutomataBase< S > &, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::final_support_t | op_final (const AutomataBase< S > &, const T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_set_initial (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, T >::series_set_elt_t &s) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_is_initial (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_set_final (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, T >::series_set_elt_t &s) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_is_final (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_set_initial (const AutomataBase< S > &, T &, int state, const typename Element< S, T >::series_set_elt_t &s) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const T &, int state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_is_initial (const AutomataBase< S > &, const T &, int state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_set_final (const AutomataBase< S > &, T &, int state, const typename Element< S, T >::series_set_elt_t &s) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const T &, int state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_is_final (const AutomataBase< S > &, const T &, int state) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_clear_initial (const AutomataBase< S > &, T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_clear_final (const AutomataBase< S > &, T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_add_state (const AutomataBase< S > &, T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_choose_state (const AutomataBase< S > &, T &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::label_t &label) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_weighted_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::semiring_elt_t &w, const typename Element< S, T >::monoid_elt_value_t &m) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_series_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::series_set_elt_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_spontaneous (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::semiring_elt_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_letter_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::letter_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::label_t &label) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_weighted_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::semiring_elt_t &w, const typename Element< S, T >::monoid_elt_value_t &m) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_series_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::series_set_elt_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_spontaneous (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::semiring_elt_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T > ::htransition_t | op_add_letter_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::letter_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_update (const AutomataBase< S > &, T &, const typename automaton_traits< T >::htransition_t &, const typename Element< S, T >::label_t &l) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_del_state (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_del_state (const AutomataBase< S > &, T &, int) |
Default conversion between value types with computation. | |
template<class S , class T > | |
void | op_del_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_has_state (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_has_state (const AutomataBase< S > &, const T &, int) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_has_transition (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_src_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_dst_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::label_t | op_label_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
const Element< S, T > ::series_set_elt_t | op_series_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T > ::series_set_elt_value_t | op_series_value_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::monoid_elt_t | op_word_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::semiring_elt_t | op_weight_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::monoid_elt_value_t | op_word_value_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, T >::letter_t | op_letter_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
bool | op_is_spontaneous (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &) |
Default conversion between value types with computation. | |
template<class S , class T > | |
Element< S, TransposeView< T > > | transpose_view (Element< S, T > &) |
This function creates a transposed view of an automaton. | |
template<class S , class T > | |
const Element< S, TransposeView< T > > | transpose_view (const Element< S, T > &) |
This function creates a transposed view of an automaton. | |
template<class S , class T > | |
automaton_traits < TransposeView< T > >::initial_support_t | op_initial (const AutomataBase< S > &, const TransposeView< T > &) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
automaton_traits < TransposeView< T > >::final_support_t | op_final (const AutomataBase< S > &, const TransposeView< T > &) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
void | op_set_initial (const AutomataBase< S > &, TransposeView< T > &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, TransposeView< T > >::series_set_elt_t &s) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
Element< S, TransposeView< T > >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::hstate_t &) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
void | op_set_final (const AutomataBase< S > &, TransposeView< T > &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, T >::series_set_elt_t &s) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::hstate_t &state) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
void | op_clear_initial (const AutomataBase< S > &, TransposeView< T > &) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
void | op_clear_final (const AutomataBase< S > &, TransposeView< T > &) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_src_of (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::htransition_t &) |
Operations on automata implemented with TransposeView. | |
template<class S , class T > | |
automaton_traits< T >::hstate_t | op_dst_of (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::htransition_t &) |
Operations on automata implemented with TransposeView. | |
Inequality operator for Structures. | |
Calls equality operator of sub-class. | |
template<typename S > | |
bool | operator!= (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b) |
Maximum length of words generated by op_choose.
To retrieve this information, just use the value named with op_choose_max_word_length
.
Definition at line 130 of file free_monoid.hh.
linearize_element<S, T>::alphabet_t vcsn::linearized_alphabet | ( | const Element< S, T > & | exp | ) | [inline] |
Computes a linearized alphabet from a rational expression.
This function returns a linearized alphabet corresponding to a rational expression, with an extra zero-letter in it.
exp | The expression to work on. |
Definition at line 49 of file berry_sethi.hxx.
References linearize().
Exp vcsn::linear_exp_continuation | ( | const Exp & | exp, | |
const Letter & | l | |||
) | [inline] |
This function computes a continuation on linearized expressions.
This include the case when letter is zero.
exp | The expression to work on. | |
l | The letter used to compute the derivation. |
Definition at line 71 of file berry_sethi.hxx.
References derivate(), and SELECT.
Referenced by BerrySethiAlgo< T_auto, S, T >::delta(), and BerrySethiAlgo< T_auto, S, T >::is_final().
bool is_cut_up | ( | const Element< A, AI > & | a | ) | [inline] |
Check if labels are series with one element.
Definition at line 37 of file cut_up.hxx.
Element< A, AI > cut_up | ( | const Element< A, AI > & | a | ) | [inline] |
Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
Definition at line 160 of file cut_up.hxx.
References Element< S, T >::structure().
Referenced by cut_up_here().
void cut_up | ( | const Element< A, AI > & | a, | |
Element< A, AI > & | res | |||
) | [inline] |
Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
Definition at line 150 of file cut_up.hxx.
References SELECT, and Element< S, T >::structure().
void cut_up_here | ( | Element< A, AI > & | a | ) | [inline] |
Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
Definition at line 170 of file cut_up.hxx.
References cut_up().
output_projection_helper<S, T>::ret vcsn::image | ( | const Element< S, T > & | src | ) | [inline] |
bool has_successors | ( | const Element< A, T > & | a, | |
const typename automaton_traits< T >::hstate_t | s | |||
) | [inline] |
Whether a state has successors.
a | Automaton. | |
s | State. |
Definition at line 26 of file has_neighbour.hxx.
References Element< S, T >::value().
bool has_predecessors | ( | const Element< A, T > & | a, | |
const typename automaton_traits< T >::hstate_t | s | |||
) | [inline] |
Whether a state has predecessors.
a | Automaton. | |
s | State. |
Definition at line 37 of file has_neighbour.hxx.
References Element< S, T >::value().
void vcsn::invert | ( | const Element< A, T > & | t, | |
Element< A, T > & | res | |||
) | [inline] |
Invert a transducer.
t | Input transducer. | |
res | Inverse transducer. |
Element<A, T>& vcsn::invert | ( | const Element< A, T > & | t | ) | [inline] |
Invert a transducer.
t | Input transducer. |
void vcsn::do_compose | ( | const AutomataBase< S > & | , | |
const algebra::FreeMonoidProduct< M1, M2 > & | , | |||
const lhs_t & | lhs, | |||
const rhs_t & | rhs, | |||
res_t & | ret | |||
) | [inline] |
Ambiguous composition.
Works only for boolean transducers.
Definition at line 337 of file normalized_composition.hxx.
References compose().
void vcsn::do_u_compose | ( | const AutomataBase< S > & | , | |
const algebra::FreeMonoidProduct< M1, M2 > & | , | |||
const lhs_t & | lhs, | |||
const rhs_t & | rhs, | |||
res_t & | ret | |||
) | [inline] |
Unambiguous composition.
Works with all type of weighted transducers.
Definition at line 359 of file normalized_composition.hxx.
References compose(), eps_removal_here(), sub_automaton_here(), and useful_states().
Element< A, AI > reduce | ( | const Element< A, AI > & | a, | |
misc::direction_type | dir = misc::right_left | |||
) | [inline] |
Reduce of an automaton (default right_left).
This algorithm computes the reduce representation of an automaton with weights in a division ring.
It is based on the explanation made by Sylvain Lombardy. A technical report about this algorithm is available here : http://www.lrde.epita.fr/cgi-bin/twiki/view/Publications/200901-Seminar-Delmon Proof and explanations are also available in ETA Chapter 3, Sec 4.3
a | The weighted automaton to reduce. | |
dir | The order in which reductions are computed. |
The weights of the automaton a must be defined in a division ring.
Definition at line 342 of file reduce.hxx.
References is_realtime(), and Element< S, T >::structure().
void reduce_here | ( | Element< A, AI > & | a, | |
misc::direction_type | dir = misc::right_left | |||
) | [inline] |
In place reduce of an automaton (default right_left).
This algorithm computes the reduce representation of an automaton with weights in a division ring.
It is based on the explanation made by Sylvain Lombardy. A technical report about this algorithm is available here : http://www.lrde.epita.fr/cgi-bin/twiki/view/Publications/200901-Seminar-Delmon Proof and explanations are also available in ETA Chapter 3, Sec 4.3
a | The weighted automaton to reduce. | |
dir | The order in which reductions are computed. |
The weights of the automaton a must be defined in a division ring.
Definition at line 360 of file reduce.hxx.
References is_realtime().
void auto_translate_transitions | ( | lhs_t & | dst, | |
const rhs_t & | from, | |||
const F & | translate_fun | |||
) | [inline] |
Element<S, TransposeView<T> > vcsn::transpose_view | ( | Element< S, T > & | a | ) | [inline] |
This function creates a transposed view of an automaton.
Referenced by transpose().
const Element<S, TransposeView<T> > vcsn::transpose_view | ( | const Element< S, T > & | a | ) | [inline] |
automaton_traits< TransposeView< T > >::initial_support_t op_initial | ( | const AutomataBase< S > & | s, | |
const TransposeView< T > & | v | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 276 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_final().
automaton_traits< TransposeView< T > >::final_support_t op_final | ( | const AutomataBase< S > & | s, | |
const TransposeView< T > & | v | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 283 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_initial().
void op_set_initial | ( | const AutomataBase< S > & | ss, | |
TransposeView< T > & | v, | |||
const typename automaton_traits< T >::hstate_t & | state, | |||
const typename Element< S, TransposeView< T > >::series_set_elt_t & | s | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 290 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_set_final().
Element< S, TransposeView< T > >::series_set_elt_t op_get_initial | ( | const AutomataBase< S > & | s, | |
const TransposeView< T > & | v, | |||
const typename automaton_traits< T >::hstate_t & | state | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 299 of file transpose_view.hxx.
References op_get_final().
void vcsn::op_set_final | ( | const AutomataBase< S > & | ss, | |
TransposeView< T > & | v, | |||
const typename automaton_traits< T >::hstate_t & | state, | |||
const typename Element< S, T >::series_set_elt_t & | s | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Element< S, T >::series_set_elt_t op_get_final | ( | const AutomataBase< S > & | s, | |
const TransposeView< T > & | v, | |||
const typename automaton_traits< T >::hstate_t & | state | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 319 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_get_initial().
void op_clear_initial | ( | const AutomataBase< S > & | s, | |
TransposeView< T > & | v | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 331 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_clear_final().
void op_clear_final | ( | const AutomataBase< S > & | s, | |
TransposeView< T > & | v | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 338 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_clear_initial().
automaton_traits< T >::hstate_t op_src_of | ( | const AutomataBase< S > & | s, | |
const TransposeView< T > & | v, | |||
const typename automaton_traits< T >::htransition_t & | e | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 345 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_dst_of().
automaton_traits< T >::hstate_t op_dst_of | ( | const AutomataBase< S > & | s, | |
const TransposeView< T > & | v, | |||
const typename automaton_traits< T >::htransition_t & | e | |||
) | [inline] |
Operations on automata implemented with TransposeView.
Definition at line 354 of file transpose_view.hxx.
References IdentityView< T >::object(), and op_src_of().