- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- Namespace List
- Namespace Members

# vcsn Namespace Reference
[Miscellaneous constructs used by Vaucanson]

The main namespace of the Vaucanson library. More...

## Classes
struct | dynamic_traits< algebra::AlphabetSetBase< S > >
| Specialization of `dynamic_traits` for `AlphabetSetBase`. More...
struct | virtual_types< algebra::AlphabetSetBase< S > >
| Specialization of `virtual_types` for `AlphabetSetBase`. More...
struct | MetaElement< algebra::AlphabetSetBase< S >, T >
| Specialization of `MetaElement` for `AlphabetSetBase`. More...
struct | dynamic_traits< algebra::FreeMonoidBase< Self > >
struct | MetaElement< algebra::FreeMonoidBase< Self >, T >
| Element of a free monoid i.e. words. More...
struct | dynamic_traits< algebra::FreeMonoidProduct< F, S > >
| Meta information about FreeMonoidProduct. More...
struct | MetaElement< algebra::FreeMonoidProduct< F, S >, T >
| Services of an element of a monoid implemented with FreeMonoidProduct. More...
struct | dynamic_traits< algebra::FreeMonoidProductBase< Self > >
struct | MetaElement< algebra::FreeMonoidProductBase< Self >, T >
| Element of a monoid i.e. words. More...
struct | dynamic_traits< algebra::MonoidBase< Self > >
struct | MetaElement< algebra::MonoidBase< Self >, T >
| Defines services of element of every monoid. More...
struct | dynamic_traits< algebra::NumericalSemiring >
| Meta information about the NumericalSemiring structural element. More...
struct | MetaElement< algebra::NumericalSemiring, T >
| Services of `Element` for numerical semirings. More...
struct | dynamic_traits< algebra::SemigroupBase< Self > >
struct | MetaElement< algebra::SemigroupBase< Self >, T >
| Services of every element of a semigroup. More...
struct | dynamic_traits< algebra::SemiringBase< Self > >
struct | MetaElement< algebra::SemiringBase< Self >, T >
| Services of every element of semiring (semiring_elt). More...
struct | op_star_traits
| Meta information about the return type of the star operation. More...
struct | dynamic_traits< algebra::SeriesBase< Self > >
class | MetaElement< algebra::SeriesBase< Self >, T >
| Services of every series. More...
struct | dynamic_traits< algebra::TropicalSemiring< TropicalKind > >
| Meta information about the tropical semirings. More...
struct | MetaElement< algebra::TropicalSemiring< TropicalKind >, T >
| Services of element of a tropical semiring. More...
struct | MetaElement< algebra::AlphabetSet< L >, std::set< L > >
| Services of every alphabet implemented with std::set. More...
struct | dynamic_traits< algebra::AlphabetSet< L > >
| Meta information about AlphabetSet. More...
struct | MetaElement< algebra::AlphabetSet< L >, algebra::AlphabetDecorator< L, T > >
| Services of every alphabet implemented with AlphabetDecorator<L, T>. More...
struct | dynamic_traits< algebra::FreeMonoid< A > >
| Meta information about FreeMonoid. More...
struct | MetaElement< algebra::FreeMonoid< A >, T >
| Services of an element of a free monoid implemented with FreeMonoid. More...
struct | MetaElement< algebra::Series< W, M >, T >
| Specialization of MetaElement for series. More...
struct | dynamic_traits< algebra::Series< W, M > >
| Dynamic traits for series. More...
struct | virtual_types< algebra::Series< W, M > >
| Virtual types for series. More...
struct | KRatExpAciCanonical
| Visitor to build a canonical form of an expression, following aci-rules. More...
struct | DefaultChooser
| Default chooser for aut_to_exp(). More...
struct | RandomChooser
| Choose randomly a state between all currently choosable. More...
class | ListChooser
| Chooser for aut_to_exp(). More...
struct | BerrySethiAlgo
| This is the visitor that really computes Berry-Sethi. More...
struct | BrzozowskiAlgo
| This is the class that really computes Brzozowski. More...
struct | KRatExpInitialDerivation
| Visitor to have an initial set of partial derivatives terms from an expression. More...
class | PRatExpDerivationVisitor
| This class performs partial rational expression derivations. More...
class | ConstantTermEval
| This is the visitor that really computes the constant term. More...
struct | KRatExpFlatten
struct | linearize_element
| The types of a linearized expression. More...
struct | FindBestSearch
| Specific implementation for search(). More...
struct | WindowedBackSearch
| Specific implementation for search(). More...
struct | dynamic_traits< Automata< Series > >
| 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...
class | Automata
| Final class for the set of automata. More...
struct | AutomataBase
| The most general concept of automaton. More...
struct | MetaElement< AutomataBase< Self >, T >
| Services of every element of the automata set. More...
class | AutoKind< labels_are_series, Self, Series, SeriesT, LabelT >
| Add adapted accessors in function of the automaton kind. More...
struct | dynamic_traits< Transducer< Series > >
| 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
| Final class for the set of transducers. More...
struct | TransducerBase
| The most general concept of transducer. More...
struct | transducer_traits
| Traits for transducer implementation. More...
struct | MetaElement< TransducerBase< Self >, T >
| Services of every element of the transducer set. More...
struct | geometry
| Store 4 maps for geometry properties of the automaton. More...
struct | edge_value
| Edge decorator. More...
struct | state_value
| State decorator. More...
class | Graph
| Graph. More...
struct | TransposeView
| Provides a transposed view of an automaton. More...
struct | transpose_traits
| Traits for TransposeView. More...
struct | automaton_traits< TransposeView< T > >
| automaton_traits specialization for the TransposeView implementation. More...
class | Element
| Glue class between structural elements and implementation values. More...
struct | op_add_traits
| The type of the result of addition between two Element instances. More...
struct | op_sub_traits
| The type of the result of substraction between two Element instances. More...
struct | op_mul_traits
| The type of the result of multiplication between two Element instances. More...
struct | op_div_traits
| The type of the result of division between two Element instances. More...
struct | op_mod_traits
| The type of the result of modulus between two Element instances. More...
struct | MetaElement< Structure< S >, T >
| The base class that glues structural elements to implementation values. More...
struct | SetSlotAttribute
| Base class for `SetSlot`. More...
struct | SetSlotAttribute< S, true >
| Base class for `SetSlot`, specializing `SetSlotAttribute`. More...
struct | SetSlot
| Type of the `set_` attribute of the `Element` class. More...
struct | Structure
| Base class for the hierarchy of structural element types. More...
struct | dynamic_traits< Structure< S > >
| Specialization of `dynamic_traits` for `Structure`. More...
struct | virtual_types< Structure< S > >
| Specialization of `virtual_types` for `Structure`. More...
struct | SyntacticDecorator
| Provides the standard operator delegations to Element. More...
## Namespaces
namespace | algebra
| Namespace for algebra constructs in Vaucanson.

namespace | misc
| The namespace for miscellaneous constructs.

namespace | delta_kind
| These are helpers for `delta` functions: transition or state oriented delta are chosen according to them.

## Typedefs
typedef misc::SparseInterval < hstate_t, std::set< hstate_t > > | StateContainer
| Needed containers.
## Enumerations
enum | op_choose_max_word_length_t
| Maximum length of words generated by op_choose. More...
## Functions
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>
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 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 | 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<typename S, typename T>
Element< S, T > | composition_cover (const Element< S, T > &fmp)
| Facade for composition cover.
template<typename S, typename T>
Element< S, T > | composition_co_cover (const Element< S, T > &fmp)
| Facade for composition co-cover.
template<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<class S, class T>
bool | is_cut_up (const Element< S, T > &a)
| Check if labels are series with one element.
template<class S, class T>
Element< S, T > | cut_up (const Element< S, T > &a)
| Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<class S, class T>
void | cut_up (const Element< S, T > &a, Element< S, T > &res)
| Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<class S, class T>
void | cut_up_here (Element< S, T > &a)
| Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<typename A, typename T, typename Exp>
void | derived_term_automaton (Element< A, T > &a, const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A, typename T, typename Exp>
Element< A, T > | derived_term_automaton (const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A, typename T, typename Exp>
Element< A, T > | broken_derived_term_automaton (const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A, typename T>
void | eps_removal_here (Element< A, T > &a, misc::direction_type dir=misc::backward)
| In place eps_removal of an automaton (default is backward eps_removal).
template<typename A, typename T>
Element< A, T > | eps_removal (const Element< A, T > &a, misc::direction_type dir=misc::backward)
| Eps_Removal of an automaton (default is backward eps_removal).
template<typename A, typename T>
void | backward_eps_removal_here (Element< A, T > &a)
| In place backward eps_removal of an automaton.
template<typename A, typename T>
Element< A, T > | backward_eps_removal (const Element< A, T > &a)
| Backward eps_removal of an automaton.
template<typename A, typename T>
void | forward_eps_removal_here (Element< A, T > &a)
| In place forward eps_removal of an automaton.
template<typename A, typename T>
Element< A, T > | forward_eps_removal (const Element< A, T > &a)
| Forward eps_removal of an automaton.
template<typename A, typename T>
void | eps_removal_here_sp (Element< A, T > &a, misc::direction_type dir=misc::backward)
| In place eps_removal_sp of an automaton (default is backward eps_removal).
template<typename A, typename T>
Element< A, T > | eps_removal_sp (const Element< A, T > &a, misc::direction_type dir=misc::backward)
| Eps_Removal of an automaton (default is backward eps_removal).
template<typename A, typename T>
void | backward_eps_removal_here_sp (Element< A, T > &a)
| In place backward eps_removal_sp of an automaton.
template<typename A, typename T>
Element< A, T > | backward_eps_removal_sp (const Element< A, T > &a)
| Backward eps_removal_sp of an automaton.
template<typename A, typename T>
void | forward_eps_removal_here_sp (Element< A, T > &a)
| In place forward eps_removal_sp of an automaton.
template<typename A, typename T>
Element< A, T > | forward_eps_removal_sp (const Element< A, T > &a)
| Forward eps_removal_sp of an automaton.
template<typename S, typename A, typename B>
bool | are_equivalent (const Element< S, A > &a, const Element< S, B > &b)
| Returns true iff the two boolean automata are equivalents, i.e., if they recognize the same language.
template<typename A, typename 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_fmp (const Element< ST, TT > &, const Element< SA, TA > &, Element< SARET, TARET > &)
| Evaluation over normalized and sub-normalized transducers, seen as automata over a free monoid product.
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<class S, class T>
output_projection_helper< S, T > ::ret | image (const Element< S, T > &)
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 A, typename T>
bool | has_successors (const Element< A, T > &a, const hstate_t s)
| Whether a state has successors.
template<typename A, typename T>
bool | has_predecessors (const Element< A, T > &a, const hstate_t s)
| Whether a state has predecessors.
template<typename A, typename T>
void | invert (const Element< A, T > &t, Element< A, T > &res)
| Invert a transducer.
template<typename A, typename T>
Element< A, T > & | invert (const Element< A, T > &t)
| Invert a transducer.
template<typename S, typename A>
bool | is_ambiguous (const Element< S, A > &aut)
| Test the ambiguity of automaton.
template<typename A, typename T>
bool | is_deterministic (const Element< A, T > &a)
| Test if an automaton is deterministic.
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 | are_isomorphic (const Element< A, T > &a, const Element< A, T > &b)
| Returns true if the two automata are isomorphic.
template<class Series, class T, class Letter>
Element< Series, T > | cderivate (const Element< Series, T > &exp, Letter a)
| The c-derivative of the krat expression w.r.t to a letter.
template<class Series, class T, class Word>
Element< Series, T > | word_cderivate (const Element< Series, T > &exp, Word a)
| The c-derivative of the krat expression w.r.t to a word.
template<class Series, class T>
std::pair< typename Element < Series, T >::semiring_elt_t, bool > | constant_term (const Element< Series, T > &exp)
| Return the constant term of the krat expression.
template<class Series, class T, class Letter>
std::pair< Element< Series, T >, bool > | derivate (const Element< Series, T > &exp, Letter a)
| The antimirov derivative of the krat expression w.r.t to a letter.
template<class Series, class T, class Word>
std::pair< Element< Series, T >, bool > | word_derivate (const Element< Series, T > &exp, Word a)
| The antimirov derivative of the krat expression w.r.t to a word.
template<class Series, class T>
std::list< typename Series::monoid_t::alphabet_t::letter_t > | flatten (const Element< Series, T > &exp)
| This algorithm extracts the letters from a rational expression.
template<class Series, class T>
linearize_element< Series, T > ::element_t | linearize (const Element< Series, T > &exp)
| The linearization of the krat expression.
template<class Series, class T, class Letter>
std::pair< std::set< Element < Series, T > >, bool > | partial_derivate (const Element< Series, T > &exp, Letter a)
| The partial derivative of the krat expression w.r.t to a letter.
template<class S, class T>
Element< S, T > | letter_to_letter_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Undocumented.
template<typename A, typename 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>
Element< A, T > | co_minimization_moore (const Element< A, T > &a)
| Returns the co-minimal co-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>
void | co_minimization_moore_here (Element< A, T > &a)
| Co-minimalize the co-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 S, typename T>
void | compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
Element< S, T > | compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
void | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
Element< S, T > | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename M1, typename M2, typename lhs_t, typename rhs_t, typename res_t>
void | do_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
| Ambiguous composition.
template<typename S, typename M1, typename M2, typename lhs_t, typename rhs_t, typename res_t>
void | do_u_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
| Unambiguous composition.
template<typename auto_t, typename trans_t>
void | set_states (const trans_t &, auto_t &, std::map< hstate_t, hstate_t > &)
template<typename A, typename T>
void | realtime_here (Element< A, T > &a, misc::direction_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, misc::direction_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>
static 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>
static std::pair< bool, unsigned int > | window_backsearch (const misc::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>
static InputIterator | confirm_and_report_match (const misc::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<class S, class T>
Element< S, T > | sub_normalize (const Element< S, T > &a)
| Sub-normalize a FMP transducer.
template<class S, class T1, class T2>
void | sub_normalize (const Element< S, T1 > &a, Element< S, T2 > &res)
| Sub-normalize a FMP transducer.
template<class S, class T>
void | sub_normalize_here (Element< S, T > &a)
| Sub-normalize a FMP transducer, in place version.
template<class S, class T>
bool | is_sub_normalized (const Element< S, T > &a)
| Check if a FMP transducer is sub-normalized.
template<typename A, typename 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<typename A, typename T>
void | trim_here (Element< A, T > &a)
| Trim a.
template<class S, class T, typename OutputIterator, typename Kind>
void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
| store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void | op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
| Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void | op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
| Delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator, typename Kind>
void | op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
| Store the output spontaneous transitions.
template<class S, class T, typename Container, typename Kind>
void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
| Store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L, typename Kind>
void | op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
| Delta using a query, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void | op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
| Delta on a letter, with container output.
template<class S, class T, class Container, typename Kind>
void | op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
| Store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator, typename Kind>
void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
| Store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void | op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
| Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void | op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
| Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator, typename Kind>
void | op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
| Store the output op_spontaneous transitions.
template<class S, class T, typename Container, typename Kind>
void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
| store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L, typename Kind>
void | op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
| Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void | op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
| Reverse delta on a letter, with container output.
template<class S, class T, typename Container, typename Kind>
void | op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
| store the output op_spontaneous transitions.
template<typename lhs_t, typename rhs_t, typename F>
void | auto_translate_transitions (lhs_t &dst, const rhs_t &from, const F &translate_fun)
template<class S, class T, typename OutputIterator>
void | op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions k)
| store the output transitions 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::transitions 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::transitions k)
| store the output transitions 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::transitions 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::transitions 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::transitions 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::transitions k)
| Store the output transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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::transitions 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>
static bool | operator< (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S1, typename T1, typename S2, typename T2>
static bool | operator> (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S1, typename T1, typename S2, typename T2>
static bool | operator<= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S1, typename T1, typename S2, typename T2>
static bool | operator>= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S, typename T, typename U>
static bool | operator< (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename S, typename T, typename U>
static bool | operator> (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename S, typename T, typename U>
static bool | operator>= (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename S, typename T, typename U>
static bool | operator<= (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename U, typename S, typename T>
static bool | operator< (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename U, typename S, typename T>
static bool | operator> (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename U, typename S, typename T>
static bool | operator>= (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename U, typename S, typename T>
static bool | operator<= (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename S1, typename T1, typename S2, typename T2>
static bool | operator== (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Equality between Element instances.
template<typename S, typename T, typename U>
static bool | operator== (const vcsn::Element< S, T > &e, const U &v)
| Equality between Element and foreign values (left version).
template<typename U, typename S, typename T>
static bool | operator== (const U &v, const vcsn::Element< S, T > &e)
| Equality between Element and foreign values (right version).
template<typename S1, typename T1, typename S2, typename T2>
static bool | operator!= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Difference between Element instances.
template<typename S, typename T, typename U>
static bool | operator!= (const vcsn::Element< S, T > &e, const U &v)
| Difference between Element and foreign values (left version).
template<typename U, typename S, typename T>
static bool | operator!= (const U &v, const vcsn::Element< S, T > &e)
| Difference between Element and foreign values (right version).
template<typename S1, typename T1, typename S2, typename T2>
static vcsn::op_add_traits< S1, S2, T1, T2 >::ret_t | operator+ (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Addition between Element instances.
template<typename S, typename T, typename U>
static vcsn::Element< S, T > | operator+ (const vcsn::Element< S, T > &e, const U &v)
| Addition between Element and foreign values (left).
template<typename U, typename S, typename T>
static vcsn::Element< S, T > | operator+ (const U &v, const vcsn::Element< S, T > &e)
| Addition between Element and foreign values (right).
template<typename S1, typename T1, typename S2, typename T2>
static vcsn::op_sub_traits< S1, S2, T1, T2 >::ret_t | operator- (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Substraction between Element instances.
template<typename S, typename T, typename U>
static vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &e, const U &v)
| Substraction between Element and foreign values (left).
template<typename U, typename S, typename T>
static vcsn::Element< S, T > | operator- (const U &v, const vcsn::Element< S, T > &e)
| Substraction between Element and foreign values (right).
template<typename S1, typename T1, typename S2, typename T2>
static vcsn::op_mul_traits< S1, S2, T1, T2 >::ret_t | operator * (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Multiplication between Element instances.
template<typename S, typename T, typename U>
static vcsn::Element< S, T > | operator * (const vcsn::Element< S, T > &e, const U &v)
| Multiplication between Element and foreign values (left).
template<typename U, typename S, typename T>
static vcsn::Element< S, T > | operator * (const U &v, const vcsn::Element< S, T > &e)
| Multiplication between Element and foreign values (right).
template<typename S1, typename T1, typename S2, typename T2>
static vcsn::op_div_traits< S1, S2, T1, T2 >::ret_t | operator/ (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Division between Element instances.
template<typename S, typename T, typename U>
static vcsn::Element< S, T > | operator/ (const vcsn::Element< S, T > &e, const U &v)
| Division between Element and foreign values (left).
template<typename U, typename S, typename T>
static vcsn::Element< S, T > | operator/ (const U &v, const vcsn::Element< S, T > &e)
| Division between Element and foreign values (right).
template<typename S1, typename T1, typename S2, typename T2>
static vcsn::op_mod_traits< S1, S2, T1, T2 >::ret_t | operator% (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Modulus between Element instances.
template<typename S, typename T, typename U>
static vcsn::Element< S, T > | operator% (const vcsn::Element< S, T > &e, const U &v)
| Modulus between Element and foreign values (left).
template<typename U, typename S, typename T>
static vcsn::Element< S, T > | operator% (const U &v, const vcsn::Element< S, T > &e)
| Modulus between Element and foreign values (right.
template<typename S, typename T>
static vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &)
| Unary negation of Element instances.
template<typename St, typename S, typename T>
static St & | operator<< (St &s, const vcsn::Element< S, T > &e)
| Output to stream.
template<typename St, typename S, typename T>
static St & | operator>> (St &s, const vcsn::Element< S, T > &e)
| Input from stream.
Determinization algorithms
template<typename A, typename 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 > > &m)
| Returns the determinized of a Boolean automaton.
FMP automaton to realtime transducer algorithm.
Compute the equivalent transducer of a FMP automaton. Please note that for the moment this function works only if the support of each transition is finite. Algorithm : If the FMP contains transitions with "complex" expression (E), i.e. infinite support, then Thompson of E. With the resulting automaton apply a conversion. i.e. (a,x) -> a|x
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > & | fmp_to_realtime (const Element< S, T > &fmp, Element< SS, TT > &res)
Product algorithm
Precondition: is_realtime. Returns a fresh automaton that is the product of the two input ones.
template<typename A, typename T, typename U>
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, const bool use_geometry=false)
template<typename A, typename T, typename U>
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< hstate_t, std::pair< hstate_t, hstate_t > > &, const bool use_geometry=false)
Realtime transducer to FMP automaton algorithm
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > & | realtime_to_fmp (const Element< S, T > &trans, Element< SS, TT > &res)
| Compute the equivalent FMP automaton of a transducer.
Default operation on automata.
template<class S, class T>
const automaton_traits< T > ::tag_t & | op_get_tag (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::tag_t & | op_get_tag (const AutomataBase< S > &, T &)
template<class S, class T>
const automaton_traits< T > ::geometry_t & | op_get_geometry (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::geometry_t & | op_get_geometry (const AutomataBase< S > &, T &)
template<class S, class T>
bool | op_exists (const AutomataBase< S > &s, const T &)
template<class S, class T>
automaton_traits< T >::states_t | op_states (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T > ::transitions_t | op_transitions (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T > ::initial_support_t | op_initial (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T > ::final_support_t | op_final (const AutomataBase< S > &, const T &)
template<class S, class T>
void | op_set_initial (const AutomataBase< S > &, T &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
template<class S, class T>
Element< S, T >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const T &, hstate_t state)
template<class S, class T>
void | op_set_final (const AutomataBase< S > &, T &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
template<class S, class T>
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const T &, hstate_t state)
template<class S, class T>
void | op_clear_initial (const AutomataBase< S > &, T &)
template<class S, class T>
void | op_clear_final (const AutomataBase< S > &, T &)
template<class S, class T>
hstate_t | op_add_state (const AutomataBase< S > &, T &)
template<class S, class T>
hstate_t | op_choose_state (const AutomataBase< S > &, T &)
template<class S, class T>
htransition_t | op_add_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::label_t &label)
template<class S, class T>
htransition_t | op_add_weighted_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::semiring_elt_t &w, const typename Element< S, T >::monoid_elt_value_t &m)
template<class S, class T>
htransition_t | op_add_series_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::series_set_elt_t &)
template<class S, class T>
htransition_t | op_add_spontaneous (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::semiring_elt_t &)
template<class S, class T>
htransition_t | op_add_letter_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::letter_t &)
template<class S, class T>
void | op_update (const AutomataBase< S > &, T &, htransition_t, const typename Element< S, T >::label_t &l)
template<class S, class T>
void | op_del_state (const AutomataBase< S > &, T &, hstate_t)
template<class S, class T>
void | op_del_transition (const AutomataBase< S > &, T &, htransition_t)
template<class S, class T>
bool | op_has_state (const AutomataBase< S > &, const T &, hstate_t)
template<class S, class T>
bool | op_has_transition (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
hstate_t | op_src_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
hstate_t | op_dst_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::label_t | op_label_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
const Element< S, T > ::series_set_elt_t | op_series_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T > ::series_set_elt_value_t | op_series_value_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::monoid_elt_t | op_word_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::semiring_elt_t | op_weight_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::monoid_elt_value_t | op_word_value_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::letter_t | op_letter_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
bool | op_is_spontaneous (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, TransposeView< T > > | transpose_view (Element< S, T > &)
| This function creates a transposed view of an automaton.
template<class S, class T>
const Element< S, TransposeView< T > > | transpose_view (const Element< S, T > &)
| This function creates a transposed view of an automaton.
template<class S, class T>
automaton_traits < TransposeView< T > >::initial_support_t | op_initial (const AutomataBase< S > &, const TransposeView< T > &)
| Operations on automata implemented with TransposeView.
template<class S, class T>
automaton_traits < TransposeView< T > >::final_support_t | op_final (const AutomataBase< S > &, const TransposeView< T > &)
| Operations on automata implemented with TransposeView.
template<class S, class T>
void | op_set_initial (const AutomataBase< S > &, TransposeView< T > &, 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_src_of (const AutomataBase< S > &, const TransposeView< T > &, htransition_t)
| Operations on automata implemented with TransposeView.
template<class S, class T>
hstate_t | op_dst_of (const AutomataBase< S > &, const TransposeView< T > &, htransition_t)
| Operations on automata implemented with TransposeView.
Inequality operator for Structures.
Calls equality operator of sub-class.
template<typename S>
bool | operator!= (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b)

## Detailed Description

The main namespace of the Vaucanson library.

Bug:
  FIXME: misc::limits should be removed, or std::numeric_limits should not be used/specialized.

## Typedef Documentation

typedef misc::SparseInterval<hstate_t, std::set<hstate_t> > StateContainer

Needed containers.

FIXME: How about using std::vector instead of std::set?

Definition at line 76 of file graph.hh.

## Enumeration Type Documentation

enum op_choose_max_word_length_t

Maximum length of words generated by op_choose.

To retrieve this information, just use the value named with `op_choose_max_word_length`.

Definition at line 112 of file words.hh.

## Function Documentation

linearize_element<S, T>::alphabet_t vcsn::linearized_alphabet | ( | const Element< S, T > & | exp | ) | `[inline]`

Computes a linearized alphabet from a rational expression.

This function returns a linearized alphabet corresponding to a rational expression, with an extra zero-letter in it.

Parameters:

  | exp | The expression to work on.

Author:
  Loic Fosse <loic@lrde.epita.fr>

See also:
  linearize()

Definition at line 49 of file berry_sethi.hxx.

References linearize().

Exp vcsn::linear_exp_continuation | ( | const Exp & | exp,
|  | const Letter & | l |
| ) |  |  | `[inline]`

This function computes a continuation on linearized expressions.

This include the case when letter is zero.

Parameters:

  | exp | The expression to work on.
  | l | The letter used to compute the derivation.

Author:
  Loic Fosse <loic@lrde.epita.fr>

Definition at line 71 of file berry_sethi.hxx.

References derivate(), and SELECT.

Referenced by BerrySethiAlgo::delta(), and BerrySethiAlgo::is_final().

bool is_cut_up | ( | const Element< S, T > & | a | ) | `[inline]`

Check if labels are series with one element.

- a Input automaton.
  Returns:
    is cut-up.

Definition at line 37 of file cut_up.hxx.

Element< S, T > cut_up | ( | const Element< S, T > & | a | ) | `[inline]`

Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.

Note:
  No cut-up work is done on input and output transitions.

Works on all automata and transducers labeled with polynomial series, and on automata labeled with rational series.

- a Input automaton.
  Returns:
    Output automaton.

Definition at line 159 of file cut_up.hxx.

References Element::structure().

Referenced by cut_up_here().

void cut_up | ( | const Element< S, T > & | a,
|  | Element< S, T > & | res |
| ) |  |  | `[inline]`

Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.

Note:
  No cut-up work is done on input and output transitions.

Works on all automata and transducers labeled with polynomial series, and on automata labeled with rational series.

- a Input automaton.
- res Output automaton.

Definition at line 149 of file cut_up.hxx.

References SELECT, and Element::structure().

void cut_up_here | ( | Element< S, T > & | a | ) | `[inline]`

Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.

Note:
  No cut-up work is done on input and output transitions.

Works on all automata and transducers labeled with polynomial series, and on automata labeled with rational series.

- a Input automaton.

Definition at line 169 of file cut_up.hxx.

References cut_up().

output_projection_helper< S, T >::ret image | ( | const Element< S, T > & | src | ) | `[inline]`

Definition at line 256 of file image.hxx.

References Element::structure().

bool has_successors | ( | const Element< A, T > & | a,
|  | const hstate_t | s |
| ) |  |  | `[inline]`

Whether a state has successors.

Parameters:

  | a | Automaton.
  | s | State.

Returns:
  True is the state s has successors.

Definition at line 39 of file has_neighbour.hxx.

bool has_predecessors | ( | const Element< A, T > & | a,
|  | const hstate_t | s |
| ) |  |  | `[inline]`

Whether a state has predecessors.

Parameters:

  | a | Automaton.
  | s | State.

Returns:
  True is the state s has predecessors.

Definition at line 49 of file has_neighbour.hxx.

void vcsn::invert | ( | const Element< A, T > & | t,
|  | Element< A, T > & | res |
| ) |  |  | `[inline]`

Invert a transducer.

Parameters:

  | t | Input transducer.
  | res | Inverse transducer.

Element<A, T>& vcsn::invert | ( | const Element< A, T > & | t | ) | `[inline]`

Invert a transducer.

Parameters:

  | t | Input transducer.

Returns:
  Inverse transducer.

void vcsn::do_compose | ( | const AutomataBase< S > & | ,
|  | const algebra::FreeMonoidProduct< M1, M2 > & | ,
|  | const lhs_t & | lhs,
|  | const rhs_t & | rhs,
|  | res_t & | ret |
| ) |  |  | `[inline]`

Ambiguous composition.

Works only for boolean transducers.

Definition at line 337 of file normalized_composition.hxx.

References compose().

void vcsn::do_u_compose | ( | const AutomataBase< S > & | ,
|  | const algebra::FreeMonoidProduct< M1, M2 > & | ,
|  | const lhs_t & | lhs,
|  | const rhs_t & | rhs,
|  | res_t & | ret |
| ) |  |  | `[inline]`

Unambiguous composition.

Works with all type of weighted transducers.

Definition at line 360 of file normalized_composition.hxx.

References compose(), eps_removal_here(), sub_automaton_here(), and useful_states().

Referenced by u_compose().

void auto_translate_transitions | ( | lhs_t & | dst,
|  | const rhs_t & | from,
|  | const F & | translate_fun |
| ) |  |  | `[inline]`

Bug:
  Write documentation and tests.

Definition at line 27 of file translate.hxx.

void op_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output transitions of the state 'from' using 'res'.

Definition at line 381 of file automaton_view.hxx.

References op_delta().

void op_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output transitions of the state 'from' where query(label(e)) = true using 'res'.

Definition at line 392 of file automaton_view.hxx.

References op_delta().

void op_letter_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output transitions of the state 'from' where the label matches the letter.

Definition at line 404 of file automaton_view.hxx.

References op_letter_delta().

void op_spontaneous_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output spontaneous transitions.

Definition at line 416 of file automaton_view.hxx.

References op_spontaneous_delta().

void op_spontaneous_deltac | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 463 of file automaton_view.hxx.

References op_spontaneous_deltac().

void op_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output states of the state 'from' using 'res'.

Definition at line 477 of file automaton_view.hxx.

References op_delta().

void op_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output states of the state 'from' where query(label(e)) = true using 'res'.

Definition at line 487 of file automaton_view.hxx.

References op_delta().

void op_letter_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output states of the state 'from' where the label matches the letter.

Definition at line 498 of file automaton_view.hxx.

References op_letter_delta().

void op_spontaneous_delta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 509 of file automaton_view.hxx.

References op_spontaneous_delta().

void op_spontaneous_deltac | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 553 of file automaton_view.hxx.

References op_spontaneous_deltac().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output transitions of the state 'from' using 'res'.

Definition at line 567 of file automaton_view.hxx.

References op_rdelta().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output transitions of the state 'from' where query(label(e)) = true using 'res'.

Definition at line 576 of file automaton_view.hxx.

References op_rdelta().

void op_letter_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output transitions of the state 'from' where the label matches the letter.

Definition at line 586 of file automaton_view.hxx.

References op_letter_rdelta().

void op_spontaneous_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 596 of file automaton_view.hxx.

References op_spontaneous_rdelta().

void op_spontaneous_rdeltac | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 637 of file automaton_view.hxx.

References op_spontaneous_rdeltac().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output states of the state 'from' using 'res'.

Definition at line 651 of file automaton_view.hxx.

References op_rdelta().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output states of the state 'from' where query(label(e)) = true using 'res'.

Definition at line 660 of file automaton_view.hxx.

References op_rdelta().

void op_letter_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output states of the state 'from' where the label matches the letter.

Definition at line 670 of file automaton_view.hxx.

References op_letter_rdelta().

void op_spontaneous_rdelta | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 680 of file automaton_view.hxx.

References op_spontaneous_rdelta().

void op_spontaneous_rdeltac | ( | const AutomataBase< S > & | s,
|  | const IdentityView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

store the output op_spontaneous transitions.

Definition at line 721 of file automaton_view.hxx.

Element< S, TransposeView< T > > transpose_view | ( | Element< S, T > & | a | ) | `[inline]`

This function creates a transposed view of an automaton.

See also:
  transpose(), TransposeView

Definition at line 48 of file transpose_view.hxx.

References Element::structure(), and Element::value().

Referenced by transpose().

const Element< S, TransposeView< T > > transpose_view | ( | const Element< S, T > & | a | ) | `[inline]`

This function creates a transposed view of an automaton.

See also:
  transpose(), TransposeView

Definition at line 56 of file transpose_view.hxx.

References Element::structure(), and Element::value().

automaton_traits< TransposeView< T > >::initial_support_t op_initial | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 276 of file transpose_view.hxx.

References IdentityView::object().

automaton_traits< TransposeView< T > >::final_support_t op_final | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 283 of file transpose_view.hxx.

References IdentityView::object().

void op_set_initial | ( | const AutomataBase< S > & | ss,
|  | TransposeView< T > & | v,
|  | hstate_t | state,
|  | const typename Element< S, TransposeView< T > >::series_set_elt_t & | s |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 290 of file transpose_view.hxx.

References IdentityView::object().

Element< S, TransposeView< T > >::series_set_elt_t op_get_initial | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | hstate_t | state |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 299 of file transpose_view.hxx.

void op_set_final | ( | const AutomataBase< S > & | ss,
|  | TransposeView< T > & | v,
|  | hstate_t | state,
|  | const typename Element< S, T >::series_set_elt_t & | s |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 310 of file transpose_view.hxx.

References IdentityView::object().

Element< S, T >::series_set_elt_t op_get_final | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | hstate_t | state |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 319 of file transpose_view.hxx.

References IdentityView::object().

void op_clear_initial | ( | const AutomataBase< S > & | s,
|  | TransposeView< T > & | v |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 331 of file transpose_view.hxx.

References IdentityView::object().

void op_clear_final | ( | const AutomataBase< S > & | s,
|  | TransposeView< T > & | v |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 338 of file transpose_view.hxx.

References IdentityView::object().

hstate_t op_src_of | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | htransition_t | e |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 345 of file transpose_view.hxx.

References IdentityView::object().

hstate_t op_dst_of | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | htransition_t | e |
| ) |  |  | `[inline]`

Operations on automata implemented with TransposeView.

Definition at line 354 of file transpose_view.hxx.

References IdentityView::object().

void op_delta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Delta with a query and iterator output.

Store the output transitions of the state 'from' where query(label(e)) is true using 'res'.

Definition at line 378 of file transpose_view.hxx.

References IdentityView::object(), and op_rdelta().

void op_letter_delta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Delta on a letter with iterator output.

Store the output transitions of the state 'from' where the label matches the letter.

Definition at line 390 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_rdelta().

void op_deltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Delta with a query and container output.

Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'.

Definition at line 426 of file transpose_view.hxx.

References IdentityView::object(), and op_rdeltac().

void op_letter_deltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Delta on a letter with container output.

Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'.

Definition at line 438 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_rdeltac().

void op_delta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Delta with no condition and iterator output.

Store the output states of the state 'from' using 'res'.

Definition at line 463 of file transpose_view.hxx.

References IdentityView::object(), and op_rdelta().

void op_delta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Delta using a query, with iterator output.

Store the output states of the state 'from' where query(label(e)) is true using 'res'.

Definition at line 473 of file transpose_view.hxx.

References IdentityView::object(), and op_rdelta().

void op_letter_delta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Delta on a letter with iterator output.

Store the output states of the state 'from' where the label matches the letter.

Definition at line 484 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_rdelta().

void op_deltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Delta without condition, container output.

Store the output states of the state 'from' in the container 'res'.

Definition at line 509 of file transpose_view.hxx.

References IdentityView::object(), and op_rdeltac().

void op_deltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

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'.

Definition at line 517 of file transpose_view.hxx.

References IdentityView::object(), and op_rdeltac().

void op_letter_deltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

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'.

Definition at line 528 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_rdeltac().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Reverse delta without condition, and iterator output.

Store the output transitions of the state 'from' using 'res'.

Definition at line 553 of file transpose_view.hxx.

References IdentityView::object(), and op_delta().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Reverse delta with query, with iterator output.

Store the output transitions of the state 'from' where query(label(e)) is true using 'res'.

Definition at line 562 of file transpose_view.hxx.

References IdentityView::object(), and op_delta().

void op_letter_rdelta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Reverse delta on a letter, with iterator output.

Store the output transitions of the state 'from' where the label matches the letter.

Definition at line 572 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_delta().

void op_rdeltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Reverse delta on a container, with no condition.

Store the output transitions of the state 'from' in the container 'res'.

Definition at line 596 of file transpose_view.hxx.

References IdentityView::object(), and op_deltac().

void op_rdeltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Reverse delta using a query, with container output.

Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'.

Definition at line 603 of file transpose_view.hxx.

References IdentityView::object(), and op_deltac().

void op_letter_rdeltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::transitions | k |
| ) |  |  | `[inline]`

Reverse delta on a letter, with container output.

Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'.

Definition at line 613 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_deltac().

void op_rdelta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Reverse delta using a query, with iterator output.

Store the output states of the state 'from' where query(label(e)) is true using 'res'.

Definition at line 646 of file transpose_view.hxx.

References IdentityView::object(), and op_delta().

void op_letter_rdelta | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | OutputIterator | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Reverse delta on a letter, with iterator output.

Store the output states of the state 'from' where the label matches the letter.

Definition at line 656 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_delta().

void op_rdeltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

Reverse delta on a container, with no conditions.

Store the output states of the state 'from' in the container 'res'

Definition at line 680 of file transpose_view.hxx.

References IdentityView::object(), and op_deltac().

void op_rdeltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | query,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

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'

Definition at line 687 of file transpose_view.hxx.

References IdentityView::object(), and op_deltac().

void op_letter_rdeltac | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | Container & | res,
|  | hstate_t | from,
|  | const L & | letter,
|  | delta_kind::states | k |
| ) |  |  | `[inline]`

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.

Definition at line 697 of file transpose_view.hxx.

References IdentityView::object(), and op_letter_deltac().