|
Compounds |
| 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 ie words. More...
|
| struct | MetaElement< algebra::MonoidBase< Self >, T > |
| | Defines services of element of every monoid. More...
|
| struct | dynamic_traits< algebra::NumericalSemiring > |
| | dynamic_traits<NumericalSemiring> defines meta information about then NumericalSemiring structural element. More...
|
| struct | MetaElement< algebra::NumericalSemiring, T > |
| | MetaElement<NumericalSemiring, T> defines the services of element of 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 (weight). 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 serie. 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 | linearize_element |
| | The types of a linearized expression. 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 | TransducerBase |
| | The most general concept of transducer. More...
|
| struct | MetaElement< TransducerBase< Self >, T > |
| | Services of every element of the transducer set. 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...
|
Enumerations |
| 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> bool | parse_word (Element< S, T > &dest, const std::string &s, typename std::string::const_iterator &i, const std::list< char > &escaped=std::list< char >()) |
| | Parse the beginning of the string looking for a word.
|
|
template<typename T, typename Self> T | op_default (SELECTOR(algebra::MonoidBase< Self >), SELECTOR(T)) |
| | By default, an element of a monoid is the identity.
|
|
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 to compute the star of the weight.
|
| template<typename S, typename T> bool | op_can_choose_non_starable (const S &set, SELECTOR(T)) |
| template<typename S, typename T> Element< S, T > | op_choose_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
| template<typename S, typename T> Element< S, T > | op_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
|
template<typename S, typename T> Element< S, T > | transpose (const algebra::SeriesBase< S > &s, const T &t) |
| | returns a fresh serie 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 serie 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 serie 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 &weights, 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 &weights, 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 A_, typename Auto_> std::set< hstate_t > | do_accessible_states (const AutomataBase< A_ > &, const Auto_ &a) |
|
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_elt_t | aut_to_exp (const Element< A, T > &a) |
| | Returns a serie which describes the language of the automaton.
|
| template<typename A, typename T, typename Chooser_> Element< A, T >::series_elt_t | aut_to_exp (const Element< A, T > &a, const Chooser_ &c) |
| | Returns a serie which describes the language of the automaton.
|
| template<typename A, typename T> void | backward_closure_here (Element< A, T > &a) |
| | Complete in place the given automaton to make it close over epsilon transition.
|
| template<typename A, typename T> Element< A, T > | backward_closure (const Element< A, T > &a) |
| | Complete the given automaton into a copy to make it close over epsilon transition.
|
| template<class A_, typename Auto> void | do_backward_closure_here (const AutomataBase< A_ > &, Auto &a) |
| 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 &) |
| | Convert a krat expression into an automaton using.
|
|
template<typename A, typename T, typename Exp> void | brzozowski (Element< A, T > &, const Exp &) |
| | Convert a krat expression into an automaton using Brzozowski construction.
|
| 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 in place 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 > &) |
| | Make the transition function of an automaton total w.r.t alphabet.
|
| template<class A, class T> bool | is_complete (const Element< A, T > &e) |
| | 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> Element< A, T > | determinize (const Element< A, T > &a) |
| | Returns the determinized of a boolean automaton.
|
| 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) |
| template<typename A, typename T, typename W> Element< A, T >::weight_t | eval (const Element< A, T > &a, const W &word) |
| | Compute the image of a word into an automaton.
|
| template<typename A, typename T> void | forward_closure_here (Element< A, T > &a) |
| | Complete the given automaton into a copy to make it close over epsilon transition.
|
| template<typename A, typename T> Element< A, T > | forward_closure (const Element< A, T > &a) |
| | Complete the given automaton into a copy to make it close over epsilon transition.
|
| template<class A_, typename Auto> void | do_forward_closure_here (const AutomataBase< A_ > &, Auto &a) |
| 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 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 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 S, typename A> bool | is_realtime (const Element< S, A > &) |
| | Test to detect realtime transducers.
|
|
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 >::weight_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> 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 Series, class T> Element< Series, T > | realtime (const Element< Series, T > &exp) |
| | Expand words in the expression as a product of letters.
|
|
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> 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, 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 lhs_t, typename rhs_t, typename output_t> void | product (const AutomataBase< A > &, output_t &output, const lhs_t &lhs, const rhs_t &rhs) |
| template<typename A, typename T> bool | is_realtime (const Element< A, T > &a) |
| | Test whether an automaton is realtime.
|
| template<typename A, typename T> void | realtime_here (Element< A, T > &a, realtime_type type=forward) |
| | 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=forward) |
| | Returns a fresh realtime automaton.
|
| 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) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename OutputIterator> void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename Container> void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename OutputIterator> void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename Container> void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| template<class S, class T, typename OutputIterator> void | op_spontaneous_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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 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 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) |
| template<typename S, typename T, typename U> void | op_assign (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &src) |
| template<typename S, typename T, typename U> void | op_in_add (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
| template<typename S, typename T, typename U> void | op_in_sub (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
| template<typename S, typename T, typename U> void | op_in_mul (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
| template<typename S, typename T, typename U> void | op_in_div (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
| template<typename S, typename T, typename U> void | op_in_mod (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg) |
| template<typename S, typename T, typename U> T | op_add (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
| template<typename S, typename T, typename U> T | op_sub (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
| template<typename S, typename T, typename U> T | op_mul (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
| template<typename S, typename T, typename U> T | op_div (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
| template<typename S, typename T, typename U> T | op_mod (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2) |
| template<typename S, typename St, typename T> St & | op_rin (const Structure< S > &s, St &st, const T &v) |
| template<typename S, typename St, typename T> St & | op_rout (const Structure< S > &s, St &st, const T &v) |
|
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> bool | operator== (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b) |
| | The deep equality operator between Structure instances.
|
