|
Compounds |
struct | dynamic_traits< algebra::AlphabetSetBase< S > > |
| Specialization of dynamic_traits for AlphabetSetBase. More...
|
struct | MetaElement< algebra::AlphabetSetBase< S >, T > |
| Specialization of MetaElement for AlphabetSetBase. More...
|
struct | MetaElement< FreeMonoidBase< Self >, T > |
| Element of a free monoid ie words. More...
|
struct | MetaElement< MonoidBase< Self >, T > |
| Defines services of element of every monoid. More...
|
struct | MetaSet< NumericalSemiring > |
| MetaSet<NumericalSemiring> defines meta information about then NumericalSemiring structural element. More...
|
struct | MetaElement< 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< SeriesBase< Self >, T > |
| Services of every serie. More...
|
struct | MetaSet< TropicalSemiring< TropicalKind > > |
| Meta information about the tropical semirings. More...
|
struct | MetaElement< TropicalSemiring< TropicalKind >, T > |
| Services of element of a tropical semiring. More...
|
struct | MetaSet< algebra::AlphabetSet< L > > |
| meta information about AlphabetSet. More...
|
struct | MetaElement< AlphabetSet< L >, AlphabetDecorator< L, T > > |
| Services of every alphabet implemented with AlphabetDecorator<T>. More...
|
struct | MetaElement< AlphabetSet< L >, std::set< L > > |
| Services of every alphabet implemented with std::set. More...
|
struct | MetaSet< FreeMonoid< A > > |
| Meta information about FreeMonoid. More...
|
struct | MetaElement< 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...
|
class | TransposeImpl |
| TransposeImpl is an implementation adapter which transpose the automaton. 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 | SyntacticDecorator |
| This class provides the standard operator delegations to Element. More...
|
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) |
| 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 | stareable (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_stareable (const S &set, SELECTOR(T)) |
template<typename S, typename T> Element< S, T > | op_choose_stareable (const SemiringBase< S > &set, SELECTOR(T)) |
template<typename S, typename T> Element< S, T > | op_choose_non_stareable (const SemiringBase< S > &set, SELECTOR(T)) |
template<typename S, typename T> Element< S, T > | transpose (const 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<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> 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<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<typename A, typename T, typename W> Element< A, T >::weight_t | compute (const Element< A, T > &a, const W &word) |
| Return the image of the word in the automaton.
|
template<class A, class T> Element< A, T > | auto_concat (const Element< A, T > &lhs, const Element< A, T > &rhs) |
| Return the concatenation of two automata using epsilon transitions. */.
|
template<class A, class T> void | auto_in_concat (Element< A, T > &lhs, const Element< A, T > &rhs) |
| Return the concatenation of two automata using epsilon transitions. */.
|
template<class Self, class Auto> void | do_auto_in_concat (const AutomataBase< Self > &s, Auto &lhs, const Auto &rhs) |
template<typename A, typename T, typename Exp> void | derivates_automaton (Element< A, T > &, const Exp &) |
| Convert a krat expression into an automaton using Brzozowski construction.
|
template<typename A, typename T> Element< A, T > | determinize (const Element< A, T > &a) |
| Return a fresh determinist automaton associated to the input.
|
template<typename A, typename T> Element< A, T > | subset_construction (const Element< A, T > &a) |
| Return a fresh complete determinist automaton associated to the input.
|
template<typename A, typename T> bool | is_deterministic (const Element< A, T > &a) |
| Return true if the automaton is deterministic. */.
|
template<typename A, typename T> Element< A, T >::series_elt_t | elimination (const Element< A, T > &a) |
| Returns the series which describes the language of the automaton.
|
template<typename A, typename T, typename Chooser_> Element< A, T >::series_elt_t | elimination (const Element< A, T > &a, const Chooser_ &c) |
| 'Elimination' with a function the choose the next state to remove.
|
template<typename A, typename T, typename StatesSet> Element< A, T > | auto_extract (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 | auto_in_extract (Element< A, T > &a, const StatesSet &s, bool check_states=true) |
| Modify the input to obtain the sub-automaton defined by a set of states.
|
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_here (const Element< A, T > &a) |
| Complete the given automaton into a copy to make it close over epsilon transition.
|
template<typename A, typename T, typename Exp> void | glushkov (Element< A, T > &, const Exp &) |
| Convert a krat expression into an automaton using Glushkov construction.
|
template<typename A, typename T> Element< A, T > | hopcroft_minimization_det (const Element< A, T > &a) |
| The canonical minimal automaton of the deterministic input automaton.
|
template<typename A, typename T> Element< A, T > | hopcroft_minimization_undet (const Element< A, T > &a) |
| The canonical minimal automaton of the input automaton. (EXPERIMENTAL).
|
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> void | normalize (Element< A, T > &a) |
| In-place Thompson normalization of the automaton.
|
template<typename A, typename T> bool | is_normalized (const Element< A, T > &a) |
| Returns true if the input automaton is normalized.
|
template<typename A, typename T, typename U> void | normalized_auto_in_union (Element< A, T > &lhs, const Element< A, U > &rhs) |
| In-place union of two normalized automata.
|
template<typename A, typename T, typename U> Element< A, T > | normalized_auto_union (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Returns the fresh union of two normalized automata.
|
template<typename A, typename T, typename U> void | normalized_auto_in_concat (Element< A, T > &lhs, const Element< A, U > &rhs) |
| In-place concatenation of two normalized automata.
|
template<typename A, typename T, typename U> Element< A, T > | normalized_auto_concat (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Returns the fresh concatenation of two normalized automata.
|
template<typename A, typename T> void | normalized_auto_in_star (Element< A, T > &a) |
| In-place star transformation of the input normalized automaton.
|
template<typename A, typename T> Element< A, T > | normalized_auto_star (const Element< A, T > &a) |
| Returns the fresh star transformation of the input normalized automaton.
|
template<typename A, typename T, typename U> Element< A, T > | auto_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> void | auto_in_diagonal (Element< A, T > &) |
| In-place diagonal extraction.
|
template<typename A, typename T> Element< A, T > | auto_diagonal (const Element< A, T > &) |
| Return a fresh automaton that is the diagonal of the input one.
|
template<typename A, typename T> std::set< hstate_t > | start_reachable_states (const Element< A, T > &a) |
| Return reachables states from the input states.
|
template<typename A, typename T> Element< A, T > | auto_start_reachable (const Element< A, T > &a) |
| Extracts the sub-automaton composed of the start reachable states.
|
template<typename A, typename T> void | auto_in_start_reachable (Element< A, T > &a) |
| In-place extraction of the sub-automaton of start reachable states.
|
template<typename A, typename T> std::set< hstate_t > | final_reachable_states (const Element< A, T > &a) |
| Return co-reachables states from the final states.
|
template<typename A, typename T> Element< A, T > | auto_final_reachable (const Element< A, T > &a) |
| Extracts the sub-automaton composed of the final co-reachable states.
|
template<typename A, typename T> void | auto_in_final_reachable (Element< A, T > &a) |
| In-place extraction of the sub-automaton of final co-reachable states.
|
template<typename A, typename T> bool | is_realtime (const Element< A, T > &a) |
| Returns true if the input automaton is realtime (no epsilon transition).
|
template<typename A, typename T> void | in_realtime (Element< A, T > &a) |
| In place modification of the automaton to make it realtime.
|
template<typename A, typename T> Element< A, T > | realtime (const Element< A, T > &a) |
| Returns a fresh associated automaton that has no epsilon transitions.
|
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 | standard_auto_in_union (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 > | standard_auto_union (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 | standard_auto_in_concat (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 > | standard_auto_concat (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Return a fresh concatenation of two standard automata.
|
template<typename A, typename T> void | standard_auto_in_star (Element< A, T > &a) |
| In-place star transformation of a standard automata.
|
template<typename A, typename T> Element< A, T > | standard_auto_star (const Element< A, T > &a) |
| Return the fresh star transformation of a standard automata.
|
template<typename A, typename T, typename Letter, typename Weight> void | thompson (Element< A, T > &, const rat::exp< Letter, Weight > &) |
| The automaton associated to the krat expression using Thompson algorithm.
|
template<typename lhs_t, typename rhs_t> void | transpose (lhs_t &dst, const rhs_t &from) |
| Copy in 'dst' the transposition of 'from'.
|
template<typename auto_t> auto_t | transpose (const auto_t &from) |
| Return a fresh automaton which is the transposition of 'from'.
|
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<typename A, typename T, typename U> void | auto_in_union (Element< A, T > &lhs, const Element< A, U > &rhs) |
| Add the states and edges of 'rhs' to 'lhs'.
|
template<typename A, typename T, typename U> Element< A, T > | auto_union (const Element< A, T > &lhs, const Element< A, U > &rhs) |
| Return the fresh union of 'lhs' and 'rhs'.
|
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<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 > &se, const T &v1, const U &v2) |
| Equality between two structured values.
|
template<typename S, typename T, typename U> bool | op_lt (const Structure< S > &se, 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.
|