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 | MetaElement< algebra::FreeMonoidBase< Self >, T > |
| Element of a free monoid i.e. words. More... | |
| struct | MetaElement< algebra::MonoidBase< Self >, T > |
| Defines services of element of every monoid. More... | |
| struct | dynamic_traits< algebra::NumericalSemiring > |
| Meta information about then NumericalSemiring structural element. More... | |
| struct | MetaElement< algebra::NumericalSemiring, T > |
Services of Element for numerical semirings. More... | |
| struct | MetaElement< algebra::SemigroupBase< Self >, T > |
| Services of every element of a semigroup. More... | |
| 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... | |
| 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 | 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<T>. More... | |
| struct | MetaElement< algebra::AlphabetSet< L >, std::set< L > > |
| Services of every alphabet implemented with std::set. 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... | |
| 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... | |
| class | PRatExpDerivationVisitor |
| This class performs partial rational expression derivations. More... | |
| class | ConstantTermEval |
| This is the visitor that really computes the constant term. More... | |
| 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 > > |
| Dynamic traits for automata. More... | |
| struct | MetaElement< Automata< Series >, T > |
| MetaElement specialization for automata. More... | |
| struct | virtual_types< Automata< Series > > |
| Virtual types for automata. More... | |
| struct | AutomataBase |
| It symbolises the set of automata with multiplicity over a fixed semiring and a fixed free monoid. More... | |
| struct | MetaElement< AutomataBase< Self >, T > |
| MetaElement<AutomataBase<Self>, T> defines the interface of every automaton that is the result of the interaction of a structural element (AutomataBase<Self>) and an implementation T. More... | |
| class | AutoKind< labels_are_series, Self, Series, SeriesT, LabelT > |
| AutoKind adds methods to automaton adapted to the kind of label that are held by the internal data structure. More... | |
| struct | dynamic_traits< Transducer< Series > > |
| Dynamic traits for transducers. More... | |
| struct | MetaElement< Transducer< Series >, T > |
| Specialization of MetaElement for transducers. More... | |
| struct | virtual_types< Transducer< Series > > |
| Virtual types for transducers. More... | |
| class | Transducer |
| This is the final class for the set of transducers. More... | |
| struct | TransducerBase |
| It denotes the set of transducer with multiplicity over a fixed semiring and a fixed free couple of monoid. More... | |
| struct | MetaElement< TransducerBase< Self >, T > |
| MetaElement<TransducerBase<Self>, T> defines the interface of every transducer that is the result of the interaction of a structural element (TransducerBase<Self>) and an implementation T. More... | |
| class | Graph |
| Graph class to provide a generic implementation of 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 |
| This class provides the standard operator delegations to Element. More... | |
| class | MetaElement |
| Parent class of Element. More... | |
Determinization algorithms | |
| template<typename A, typename T> Element< A, T > | determinize (const Element< A, T > &a) |
| Returns the determinized of a Boolean automaton. | |
| template<typename A, typename T> Element< A, T > | determinize (const Element< A, T > &a, std::map< hstate_t, std::set< hstate_t > > &) |
| Returns the determinized of a Boolean automaton. | |
Evalutation algorithm's internals | |
| template<typename SE, typename TE, typename ST, typename TT, typename M> void | partial_evaluation (const Element< SE, TE > &exp, const Element< ST, TT > &trans, M &state_exp_pair) |
| The following functions are absolutely not for public calls. | |
| template<typename SA, typename TA, typename M> void | partial_elimination (const Element< SA, TA > &a, M &state_exp_pair) |
| The following functions are absolutely not for public calls. | |
| template<typename SA, typename TA, typename ST, typename TT, typename M> void | partial_1 (const Element< SA, TA > &, const Element< ST, TT > &, M &) |
| The following functions are absolutely not for public calls. | |
| template<typename SA, typename TA, typename ST, typename TT, typename Exp> void | partial_2 (const Element< SA, TA > &, const Element< ST, TT > &, const hstate_t, Exp &) |
| The following functions are absolutely not for public calls. | |
| template<typename SA, typename TA, typename ST, typename TT, typename M> void | partial_3 (const Element< SA, TA > &, const Element< ST, TT > &, const hstate_t, M &) |
| The following functions are absolutely not for public calls. | |
Product algorithm | |
| template<typename A, typename T, typename U> Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| 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, std::map< hstate_t, std::pair< hstate_t, hstate_t > > &) |
| Returns a fresh automaton that is the product of the two input ones. | |
[NOHEADER] | |
|
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. | |
[NOHEADER] | |
|
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 > &, 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 > &, hstate_t) |
| Operations on automata implemented with TransposeView. | |
| template<class S, class T> void | op_set_final (const AutomataBase< S > &, TransposeView< 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 > &, 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> hstate_t | op_origin_of (const AutomataBase< S > &, const TransposeView< T > &, hedge_t) |
| Operations on automata implemented with TransposeView. | |
| template<class S, class T> hstate_t | op_aim_of (const AutomataBase< S > &, const TransposeView< T > &, hedge_t) |
| Operations on automata implemented with TransposeView. | |
Inequality operator for Structures | |
| This operator calls equality operator of sub-class. | |
| template<typename S> bool | operator!= (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b) |
Enumerations | |
| enum | op_choose_max_word_length_t |
| Maximum length of words generated by op_choose. More... | |
| enum | realtime_type |
| Enum to indicate which kind of realtime algorithms must be used. | |
Functions | |
| template<typename S, typename St, typename T> St & | op_rout (const algebra::AlphabetSetBase< S > &s, St &st, const T &a) |
| Implementation of generic stream output operator for alphabets. | |
| template<typename S, typename T, typename L> bool | op_letter_equality (const algebra::AlphabetSetBase< S > &s, const T &a, L lhs, L rhs) |
| Implementation of generic letter equality modulo meta-characters. | |
| 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, typename CharContainer> bool | parse_word (Element< S, T > &dest, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped=CharContainer()) |
| 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> bool | op_can_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
Returns whether a non-starable Element can be choosen from a Semiring. | |
| template<typename S, typename T> Element< S, T > | op_choose_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
| Returns a random starable element in the set. | |
| template<typename S, typename T> Element< S, T > | op_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
| Returns a random non-starable element in the set. | |
| 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_letter_support (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 W, typename M, typename Tm, typename Tw> bool | op_contains (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw> void | op_in_mul (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst, const rat::exp< Tm, Tw > &arg) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> void | op_in_mul (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &ret, const oTw &w) |
| template<typename W, typename M, typename oTw, typename Tm, typename Tw> rat::exp< Tm, Tw > | op_mul (const W &semiring, const algebra::Series< W, M > &s, const oTw &w, const rat::exp< Tm, Tw > &b) |
| template<typename A, typename T> std::set< hstate_t > | accessible_states (const Element< A, T > &a) |
| Return accessible states. | |
| template<typename A, typename T> Element< A, T > | accessible (const Element< A, T > &a) |
| Extract the sub-automaton composed of accessible states. | |
| template<typename A, typename T> void | accessible_here (Element< A, T > &a) |
| In-place extract the sub-automaton of accessible states. | |
| template<typename A, typename T> std::set< hstate_t > | coaccessible_states (const Element< A, T > &a) |
| Return co-accessible states. | |
| template<typename A, typename T> Element< A, T > | coaccessible (const Element< A, T > &a) |
| Extract the sub-automaton composed of co-accessible states. | |
| template<typename A, typename T> void | coaccessible_here (Element< A, T > &a) |
| In-place extract the sub-automaton of co-accessible states. | |
| template<class Series, class T> Element< Series, T > | canonical (const Element< Series, T > &exp) |
| Transform a krat expression into its canonical form, following aci-rules. | |
| template<typename A, typename T> Element< A, T >::series_set_elt_t | aut_to_exp (const Element< A, T > &a) |
| Returns a series which describes the language of the automaton. | |
| template<typename A, typename T, typename Chooser_> Element< A, T >::series_set_elt_t | aut_to_exp (const Element< A, T > &a, const Chooser_ &c) |
| Returns a series which describes the language of the automaton. | |
| template<typename A, typename T> void | backward_realtime_here (Element< A, T > &a) |
| In place modification of the automaton to make it realtime. | |
| template<typename A, typename T> Element< A, T > | backward_realtime (const Element< A, T > &a) |
| Returns a fresh realtime 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 T> void | closure_here (Element< A, T > &a, bool bck=true) |
| In place closure of an automaton (default is backward closure). | |
| template<typename A, typename T> Element< A, T > | closure (const Element< A, T > &a, bool bck=true) |
| Closure of an automaton (default is backward closure). | |
| template<typename A, typename T> void | backward_closure_here (Element< A, T > &a) |
| In place backward closure of an automaton. | |
| template<typename A, typename T> Element< A, T > | backward_closure (const Element< A, T > &a) |
| Backward closure of an automaton. | |
| template<typename A, typename T> void | forward_closure_here (Element< A, T > &a) |
| In place forward closure of an automaton. | |
| template<typename A, typename T> Element< A, T > | forward_closure (const Element< A, T > &a) |
| Forward closure of an automaton. | |
| template<class A_, typename Auto> void | do_closure_here (const AutomataBase< A_ > &, Auto &a, bool bck_fwd) |
| template<typename A, typename T> void | complement_here (Element< A, T > &a) |
| Complement in place the set of final states. | |
| template<typename A, typename T> Element< A, T > | complement (const Element< A, T > &a) |
| Complement the set of final states. | |
| template<typename A, typename T> void | complete_here (Element< A, T > &a) |
| Make the transition function of an automaton total w.r.t alphabet. | |
| template<typename A, typename T> Element< A, T > | complete (const Element< A, T > &a) |
| Make the transition function of an automaton total w.r.t alphabet. | |
| template<class A, class T> bool | is_complete (const Element< A, T > &a) |
| Test if the transition function is complete for each state. | |
| template<class A, class T> Element< A, T > | concatenate (const Element< A, T > &lhs, const Element< A, T > &rhs) |
| Return the concatenation of two automata. | |
| template<class A, class T> void | concatenate_here (Element< A, T > &lhs, const Element< A, T > &rhs) |
| In place concatenation of two automata. | |
| template<typename A, typename T, typename Exp> void | derivatives_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 > | derivatives_automaton (const Exp &e) |
| Convert a krat expression into an automaton using derivatives. | |
| template<typename A, typename T> bool | is_deterministic (const Element< A, T > &a) |
| Test if an automaton is deterministic. | |
| template<typename A, typename input_t, typename output_t> void | do_determinize (const AutomataBase< A > &a_set, output_t &output, const input_t &input, std::map< hstate_t, std::set< hstate_t > > &m) |
| template<typename A, typename T, typename W> Element< A, T >::semiring_elt_t | eval (const Element< A, T > &a, const W &word) |
| Return the image of a word by an automaton. | |
| template<typename SA, typename TA, typename ST, typename TT, typename SARET, typename TARET> void | evaluation (const Element< SA, TA > &, const Element< ST, TT > &, Element< SARET, TARET > &) |
| Evaluate for a "letterized" automaton and a realtime transducer. | |
| template<typename S, typename T> identity_transducer_helper< S, 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<typename A, typename T> void | forward_realtime_here (Element< A, T > &a) |
| In place modification of the automaton to make it realtime. | |
| template<typename A, typename T> Element< A, T > | forward_realtime (const Element< A, T > &a) |
| Returns a fresh realtime automaton. | |
| template<typename S, typename A> bool | is_letterized_transducer (const Element< S, A > &t) |
| Test the letter to letter features. | |
| template<typename S, typename A> bool | is_normalized_transducer (const Element< S, A > &t) |
| Test the normalization of transducer. | |
| template<typename A, typename T> bool | is_isomorph (const Element< A, T > &a, const Element< A, T > &b) |
| Returns true if the two automata are isomorph. | |
| 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 T> Element< A, T > | minimization_hopcroft (const Element< A, T > &a) |
| Return the minimal automaton using the hopcroft algorithm. | |
| template<typename A, typename T> Element< A, T > | quotient (const Element< A, T > &a) |
| Return the quotient of a non deterministic acceptor. | |
| template<typename A, typename T> Element< A, T > | minimization_moore (const Element< A, T > &a) |
| Returns the minimal deterministic automaton associated to the input one. | |
| template<typename A, typename T> void | minimization_moore_here (Element< A, T > &a) |
| Minimalize the deterministic input automaton. | |
| template<typename A, typename T> Element< A, T > | normalize (const Element< A, T > &a) |
| Return the fresh thompson-normalized automaton. | |
| template<typename A, typename T> void | normalize_here (Element< A, T > &a) |
| In-place normalize to the thompson form. | |
| template<typename A, typename T> bool | is_normalized (const Element< A, T > &a) |
| Return true if the input automaton is thompson-normalized. | |
| template<typename A, typename T, typename U> void | union_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs) |
| Do the in-place union of two thompson-normalized automata. | |
| template<typename A, typename T, typename U> Element< A, T > | union_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Return the fresh union of two thompson-normalized automata. | |
| template<typename A, typename T, typename U> void | concatenate_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs) |
| Do the in-place concatenation of two thompson-normalized automata. | |
| template<typename A, typename T, typename U> Element< A, T > | concatenate_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Return the fresh concatenation of two thompson-normalized automata. | |
| template<typename A, typename T> void | star_of_normalized_here (Element< A, T > &a) |
| Do in-place star transformation on the thompson-normalized input. | |
| template<typename A, typename T> Element< A, T > | star_of_normalized (const Element< A, T > &a) |
| Return the fresh star transformation of its normalized input. | |
| template<typename A, typename T> void | realtime_here (Element< A, T > &a, realtime_type type) |
| In place modification of the automaton to make it realtime. | |
| template<typename A, typename T> Element< A, T > | realtime (const Element< A, T > &a, realtime_type type) |
| Returns a fresh realtime automaton. | |
| template<typename S, typename T> void | realtime_composition (const Element< S, T > &, const Element< S, T > &, Element< S, T > &) |
| Composition for realtime transducers. | |
| template<typename S, typename T> Element< S, T > | realtime_composition (const Element< S, T > &, const Element< S, T > &) |
| Composition for realtime transducers. | |
| template<typename S, typename T> Element< S, T > | realtime (const Element< S, T > &e) |
| Calls the do_realtime function for rational expression or automata. | |
| template<typename S, typename T> void | realtime_here (Element< S, T > &e) |
| Calls the do_realtime_here function for rational expression or automata. | |
| template<typename S, typename T> bool | is_realtime (const Element< S, T > &e) |
| Test whether an automaton or a regular expression is realtime. | |
| template<class InputIterator, class FoundFunctor, class Series, class T> void | search (const Element< Automata< Series >, T > &a, const InputIterator &begin, const InputIterator &end, typename Element< Automata< Series >, T >::letter_t eol, FoundFunctor &f) |
| Search for a rational expression into a text. | |
| template<class Series, class T, class StatesSet> unsigned int | compute_distances (const Element< Automata< Series >, T > &a, std::vector< StatesSet > &distances) |
| Compute distances from initial states to final states. | |
| template<class InputIterator, class Series, class T, class StatesSet> std::pair< bool, unsigned int > | window_backsearch (const utility::Window< InputIterator, typename Element< Automata< Series >, T >::letter_t > &w, const Element< Automata< Series >, T > &a, const std::vector< StatesSet > &distances) |
| Back search inside a window. | |
| template<class InputIterator, class FoundFunctor, class Series, class T> InputIterator | confirm_and_report_match (const utility::Window< InputIterator, typename Element< Automata< Series >, T >::letter_t > &w, const Element< Automata< Series >, T > &a, FoundFunctor &f) |
| Finds the longest match of a starting from w, and report it to the functor. | |
| template<typename A, typename T> void | standardize (Element< A, T > &a) |
| Returns a standard automaton associated to the input. | |
| template<typename A, typename T> bool | is_standard (const Element< A, T > &a) |
| Returns true if the input automaton is standard. | |
| template<typename A, typename T, typename U> void | union_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs) |
| In-place union of two standard automata. | |
| template<typename A, typename T, typename U> Element< A, T > | union_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Return a fresh union of two standard automata. | |
| template<typename A, typename T, typename U> void | concat_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs) |
| In-place concatenation of two standard automata. | |
| template<typename A, typename T, typename U> Element< A, T > | concat_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Return a fresh concatenation of two standard automata. | |
| template<typename A, typename T> void | star_of_standard_here (Element< A, T > &a) |
| In-place star transformation of a standard automata. | |
| template<typename A, typename T> Element< A, T > | star_of_standard (const Element< A, T > &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 T, typename Exp> Element< A, T > | standard_of (const Exp &e) |
| Convert a rational expression into a standard automaton. | |
| template<typename A, typename T, typename StatesSet> Element< A, T > | sub_automaton (const Element< A, T > &a, const StatesSet &s, bool check_states=true) |
| Returns a fresh automaton that is the sub-automaton defined by a set. | |
| template<typename A, typename T, typename StatesSet> void | sub_automaton_here (Element< A, T > &a, const StatesSet &s, bool check_states=true) |
| Select a sub-automaton into a given automaton. | |
| template<typename A, typename T, typename U> void | sum_here (Element< A, T > &lhs, const Element< A, U > &rhs) |
| In place summing of two automata. | |
| template<typename A, typename T, typename U> Element< A, T > | sum (const Element< A, T > &lhs, const Element< A, U > &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<class AutoType, class S, class T> Element< Automata< S >, AutoType > | thompson_of (const Element< S, T > &exp) |
| The Thompson automaton associated to the krat expression. | |
| template<typename lhs_t, typename rhs_t> void | transpose (lhs_t &dst, const rhs_t &from) |
| Transposition of an automaton. | |
| template<typename auto_t> auto_t | transpose (const auto_t &from) |
| Return a fresh transposed automaton. | |
| template<typename A, typename T> std::set< hstate_t > | useful_states (const Element< A, T > &a) |
| Returns a useful states of the automaton (start reachable and final co-). | |
| template<typename A, typename T> Element< A, T > | trim (const Element< A, T > &a) |
| Return a fresh automaton in which non useful states are removed. | |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k) |
| Delta using a query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k) |
| Delta on a letter, with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| Store the output spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k) |
| Store the output edges of the state 'from' in the container 'res'. | |
| template<class S, class T, typename Container, typename L> void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::edges k) |
| Delta using a query, with container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::edges k) |
| Delta on a letter, with container output. | |
| template<class S, class T, class Container> void | op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k) |
| Store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k) |
| Store the output states of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k) |
| Delta using a query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k) |
| Delta on a letter, with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k) |
| Store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k) |
| Store the output states of the state 'from' in the container 'res'. | |
| template<class S, class T, typename Container, typename L> void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::states k) |
| Delta using a quesry, with container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::states k) |
| Delta on a letter, with container output. | |
| template<class S, class T, typename Container> void | op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k) |
| Store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| Store the output edges of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k) |
| Reverse delta using a query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k) |
| Reverse delta on a letter, with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| Store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' in the container 'res'. | |
| template<class S, class T, typename Container, typename L> void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::edges k) |
| Reverse delta using a query, with container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::edges k) |
| Reverse delta on a letter, with container output. | |
| template<class S, class T, typename Container> void | op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output states of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k) |
| Reverse delta using a query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k) |
| Reverse delta on a letter, with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k) |
| Store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k) |
| Store the output states of the state 'from' in the container 'res'. | |
| template<class S, class T, typename Container, typename L> void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::states k) |
| Reverse delta using a query, with container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::states k) |
| Reverse delta on a letter, with container output. | |
| template<class S, class T, typename Container> void | op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k) |
| Store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k) |
| store the output edges of the state 'from' where query(label(e)) = true using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k) |
| store the output edges of the state 'from' where the label matches the letter. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k) |
| store the output edges of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k) |
| store the output edges of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, class Container> void | op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output states of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k) |
| store the output states of the state 'from' where query(label(e)) = true using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k) |
| store the output states of the state 'from' where the label matches the letter. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| store the output states of the state 'from' in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k) |
| store the output states of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k) |
| store the output states of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container> void | op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k) |
| store the output edges of the state 'from' where query(label(e)) = true using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k) |
| store the output edges of the state 'from' where the label matches the letter. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k) |
| store the output edges of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k) |
| store the output edges of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container> void | op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output states of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k) |
| store the output states of the state 'from' where query(label(e)) = true using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k) |
| store the output states of the state 'from' where the label matches the letter. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| store the output states of the state 'from' in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k) |
| store the output states of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container, typename L> void | op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k) |
| store the output states of the state 'from' where query(label(e)) = true in the container 'res' | |
| template<class S, class T, typename Container> void | op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output edges of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k) |
| Delta with a query and iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k) |
| Delta on a letter with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| Store the output spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| Store the output edges of the state 'from' in the container 'res'. | |
| template<class S, class T, typename Container, typename L> void | op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k) |
| Delta with a query and container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k) |
| Delta on a letter with container output. | |
| template<class S, class T, class Container> void | op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| Delta with no condition and iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k) |
| Delta using a query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k) |
| Delta on a letter with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| Delta without condition, container output. | |
| template<class S, class T, typename Container, typename L> void | op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k) |
| Delta with a query, using container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k) |
| Delta on a letter, with container output. | |
| template<class S, class T, typename Container> void | op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| Reverse delta without condition, and iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k) |
| Reverse delta with query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k) |
| Reverse delta on a letter, with iterator output. | |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| Reverse delta on a container, with no condition. | |
| template<class S, class T, typename Container, typename L> void | op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k) |
| Reverse delta using a query, with container output. | |
| template<class S, class T, typename Container, typename L> void | op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k) |
| Reverse delta on a letter, with container output. | |
| template<class S, class T, typename Container> void | op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k) |
| store the output op_spontaneous transitions. | |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| store the output states of the state 'from' using 'res'. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k) |
| Reverse delta using a query, with iterator output. | |
| template<class S, class T, typename OutputIterator, typename L> void | op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k) |
| Reverse delta on a letter, with iterator output. | |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| Reverse delta on a container, with no conditions. | |
| template<class S, class T, typename Container, typename L> void | op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k) |
| Reverse delta in a container, with a query. | |
| template<class S, class T, typename Container, typename L> void | op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k) |
| Reverse delta in a container, on a letter. | |
| template<class S, class T, typename Container> void | op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k) |
| Store the output op_spontaneous transitions. | |
| 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &) |
| Unary negation of Element instances. | |
| template<typename St, typename S, typename T> St & | operator<< (St &s, const vcsn::Element< S, T > &e) |
| Output to stream. | |
| template<typename St, typename S, typename T> St & | operator>> (St &s, const vcsn::Element< S, T > &e) |
| Input from stream. | |
|
||||||||||||
|
template<typename S, typename M ...>
... op(Series<S>& series, M& monoid, ...)
and should be instead:
template<typename S, typename M ...>
... op(Series<S>& series, Monoid<M>& monoid, ...)
|
|
||||||||||||||||
|
|
|
||||||||||||||||||||
|
|
|
||||||||||||||||||||
|
|
|
|
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.
|
|
||||||||||||
|
This function computes a continuation on linearized expressions. This include the case when letter is zero.
|
|
||||||||||||||||
|
|
|
||||||||||||||||||||
|
|
|
||||||||||||||||||||||||||||
|
Delta with a query and iterator output. Store the output edges of the state 'from' where query(label(e)) is true using 'res'. |
|
||||||||||||||||||||||||||||
|
Delta on a letter with iterator output. Store the output edges of the state 'from' where the label matches the letter. |
|
||||||||||||||||||||||||||||
|
Delta with a query and container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'. |
|
||||||||||||||||||||||||||||
|
Delta on a letter with container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'. |
|
||||||||||||||||||||||||
|
Delta with no condition and iterator output. Store the output states of the state 'from' using 'res'. |
|
||||||||||||||||||||||||||||
|
Delta using a query, with iterator output. Store the output states of the state 'from' where query(label(e)) is true using 'res'. |
|
||||||||||||||||||||||||||||
|
Delta on a letter with iterator output. Store the output states of the state 'from' where the label matches the letter. |
|
||||||||||||||||||||||||
|
Delta without condition, container output. Store the output states of the state 'from' in the container 'res'. |
|
||||||||||||||||||||||||||||
|
Delta with a query, using container output. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'. |
|
||||||||||||||||||||||||||||
|
Delta on a letter, with container output. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'. |
|
||||||||||||||||||||||||
|
Reverse delta without condition, and iterator output. Store the output edges of the state 'from' using 'res'. |
|
||||||||||||||||||||||||||||
|
Reverse delta with query, with iterator output. Store the output edges of the state 'from' where query(label(e)) is true using 'res'. |
|
||||||||||||||||||||||||||||
|
Reverse delta on a letter, with iterator output. Store the output edges of the state 'from' where the label matches the letter. |
|
||||||||||||||||||||||||
|
Reverse delta on a container, with no condition. Store the output edges of the state 'from' in the container 'res'. |
|
||||||||||||||||||||||||||||
|
Reverse delta using a query, with container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'. |
|
||||||||||||||||||||||||||||
|
Reverse delta on a letter, with container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'. |
|
||||||||||||||||||||||||||||
|
Reverse delta using a query, with iterator output. Store the output states of the state 'from' where query(label(e)) is true using 'res'. |
|
||||||||||||||||||||||||||||
|
Reverse delta on a letter, with iterator output. Store the output states of the state 'from' where the label matches the letter. |
|
||||||||||||||||||||||||
|
Reverse delta on a container, with no conditions. Store the output states of the state 'from' in the container 'res' |
|
||||||||||||||||||||||||||||
|
Reverse delta in a container, with a query. Store the output states of the state 'from' where query(label(e)) is true in the container 'res' |
|
||||||||||||||||||||||||||||
|
Reverse delta in a container, on a letter. Store in the container 'res' the output states of the state 'from' where query(label(e)) is true. |
1.3.7