# vcsn Namespace Reference
[Miscellaneous constructs used by Vaucanson]

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

## Namespaces

namespace | algebra

| Namespace for algebra constructs in Vaucanson.
namespace | delta_kind

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

| The namespace for miscellaneous constructs.

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

## Enumerations

enum | op_choose_max_word_length_t
| Maximum length of words generated by op_choose. More...

## Functions

template<typename S , typename T >
std::pair< bool, typename Element< S, T >::letter_t > | parse_letter (const Element< S, T > &alphabet, const std::string &s)
| Public interface to the letter parser.
template<typename S , typename T >
Element< S, T > | mirror (const Element< S, T > &e)
| Return a fresh word that is the mirror.
template<typename S , typename T >
std::pair< bool, int > | parse_word (Element< S, T > &dest, const std::string &s)
| Parse the beginning of the string looking for a word.
template<typename S , typename T >
op_star_traits< S, T >::ret_t | star (const Element< S, T > &w)
| Returns a fresh weight that is the star of w.
template<typename S , typename T >
bool | parse_weight (Element< S, T > &w, const std::string &, typename std::string::const_iterator &)
| Parse the beginning of the string looking for a weight.
template<typename S , typename T >
bool | starable (const Element< S, T > &elt)
| Returns true if we can compute the star of the weight.
template<typename S , typename T >
Element< S, T > | transpose (const algebra::SeriesBase< S > &s, const T &t)
| returns a fresh series that is the transposed of the argument.
template<typename S , typename T >
bool | is_support_in_alphabet (const Element< S, T > &s)
| Returns true if the support of the series is only composed of letters.
template<typename S1 , typename S2 , typename T1 , typename T2 >
void | extract_support (Element< S1, T1 > &, Element< S2, T2 > &)
| Make the first series be the support of the second.
template<class S , class T >
Element< S, T > | hadamard (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Return the hadamard product of lhs and rhs.
template<typename A , typename AI >
std::set< typename Element< A, AI >::hstate_t > | accessible_states (const Element< A, AI > &a)
| Return accessible states.
template<typename A , typename AI >
Element< A, AI > | accessible (const Element< A, AI > &a)
| Extract the sub-automaton composed of accessible states.
template<typename A , typename AI >
void | accessible_here (Element< A, AI > &a)
| In-place extract the sub-automaton of accessible states.
template<typename A , typename AI >
std::set< typename Element< A, AI >::hstate_t > | coaccessible_states (const Element< A, AI > &a)
| Return co-accessible states.
template<typename A , typename AI >
Element< A, AI > | coaccessible (const Element< A, AI > &a)
| Extract the sub-automaton composed of co-accessible states.
template<typename A , typename AI >
void | coaccessible_here (Element< A, AI > &a)
| In-place extract the sub-automaton of co-accessible states.
template<typename S , typename SI >
Element< S, SI > | canonical (const Element< S, SI > &exp)
| Transform a krat expression into a canonical form using only ACI-rules.
template<typename A , typename AI >
Element< A, AI >::series_set_elt_t | aut_to_exp (const Element< A, AI > &a)
| Returns a series which describes the language of the automaton.
template<typename A , typename AI , typename Chooser >
Element< A, AI >::series_set_elt_t | aut_to_exp (const Element< A, AI > &a, const Chooser &c)
| Returns a series which describes the language of the automaton.
template<typename A , typename T , typename Exp >
void | berry_sethi (Element< A, T > &, const Exp &)
| Build an automaton from an expression using the Berry-Sethi construction.
template<typename S , typename T >
linearize_element< S, T > ::alphabet_t | linearized_alphabet (const Element< S, T > &exp)
| Computes a linearized alphabet from a rational expression.
template<typename Exp , typename Letter >
Exp | linear_exp_continuation (const Exp &exp, const Letter &l)
| This function computes a continuation on linearized expressions.
template<typename A , typename T , typename Exp >
void | brzozowski (Element< A, T > &, const Exp &)
| Build an automaton from an expression using the Brzozowski construction.
template<typename lhs_t , typename rhs_t >
void | characteristic (lhs_t &dst, const rhs_t &from)
| Build a characteristic automaton.
template<typename A , typename AI >
void | complement_here (Element< A, AI > &a)
| Complement in place the set of final states.
template<typename A , typename AI >
Element< A, AI > | complement (const Element< A, AI > &a)
| Complement the set of final states.
template<typename A , typename AI >
void | complete_here (Element< A, AI > &a)
| Make the transition function of an automaton total w.r.t.
template<typename A , typename AI >
Element< A, AI > | complete (const Element< A, AI > &a)
| Make the transition function of an automaton total w.r.t.
template<typename A , typename AI >
bool | is_complete (const Element< A, AI > &a)
| Test whether an automaton is complete.
template<typename S , typename T >
Element< S, T > | composition_cover (const Element< S, T > &fmp)
| Facade for composition cover.
template<typename S , typename T >
Element< S, T > | composition_co_cover (const Element< S, T > &fmp)
| Facade for composition co-cover.
template<typename A , typename AI >
bool | is_cut_up (const Element< A, AI > &a)
| Check if labels are series with one element.
template<typename A , typename AI >
Element< A, AI > | cut_up (const Element< A, AI > &a)
| Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<typename A , typename AI >
void | cut_up (const Element< A, AI > &a, Element< A, AI > &res)
| Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<typename A , typename AI >
void | cut_up_here (Element< A, AI > &a)
| Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<typename A , typename T , typename Exp >
void | derived_term_automaton (Element< A, T > &a, const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A , typename T , typename Exp >
Element< A, T > | derived_term_automaton (const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A , typename T , typename Exp >
Element< A, T > | broken_derived_term_automaton (const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A , typename AI >
bool | is_proper (const Element< A, AI > &a)
| Test whether an automaton is proper.
template<typename A , typename AI >
void | eps_removal_here (Element< A, AI > &a, misc::direction_type dir=misc::backward)
| In place eps_removal of an automaton (default is backward eps_removal).
template<typename A , typename AI >
Element< A, AI > | eps_removal (const Element< A, AI > &a, misc::direction_type dir=misc::backward)
| Eps_Removal of an automaton (default is backward eps_removal).
template<typename A , typename AI >
void | backward_eps_removal_here (Element< A, AI > &a)
| In place backward eps_removal of an automaton.
template<typename A , typename AI >
Element< A, AI > | backward_eps_removal (const Element< A, AI > &a)
| Backward eps_removal of an automaton.
template<typename A , typename AI >
void | forward_eps_removal_here (Element< A, AI > &a)
| In place forward eps_removal of an automaton.
template<typename A , typename AI >
Element< A, AI > | forward_eps_removal (const Element< A, AI > &a)
| Forward eps_removal of an automaton.
template<typename A , typename AI >
void | eps_removal_here_sp (Element< A, AI > &a, misc::direction_type dir=misc::backward)
| In place eps_removal_sp of an automaton (default is backward eps_removal).
template<typename A , typename AI >
Element< A, AI > | eps_removal_sp (const Element< A, AI > &a, misc::direction_type dir=misc::backward)
| Eps_Removal of an automaton (default is backward eps_removal).
template<typename A , typename AI >
void | backward_eps_removal_here_sp (Element< A, AI > &a)
| In place backward eps_removal_sp of an automaton.
template<typename A , typename AI >
Element< A, AI > | backward_eps_removal_sp (const Element< A, AI > &a)
| Backward eps_removal_sp of an automaton.
template<typename A , typename AI >
void | forward_eps_removal_here_sp (Element< A, AI > &a)
| In place forward eps_removal_sp of an automaton.
template<typename A , typename AI >
Element< A, AI > | forward_eps_removal_sp (const Element< A, AI > &a)
| Forward eps_removal_sp of an automaton.
template<typename S , typename A , typename B >
bool | are_equivalent (const Element< S, A > &a, const Element< S, B > &b)
| Returns true iff the two boolean automata are equivalents, i.e., if they recognize the same language.
template<typename A , typename AI , typename W >
Element< A, AI >::semiring_elt_t | eval (const Element< A, AI > &a, const W &word)
| Return the image of a word by an automaton.
template<typename ST , typename TT >
void | evaluation_fmp (const Element< ST, TT > &, const typename input_projection_helper< ST, TT >::ret &, typename output_projection_helper< ST, TT >::ret &)
| Evaluation over normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename SA , typename TA , typename ST , typename TT , typename SRET , typename TRET >
void | evaluation_rw (const Element< SA, TA > &a, const Element< ST, TT > &t, Element< SRET, TRET > &ret)
| Evaluate for a "letterized" automaton and a realtime transducer.
template<typename S , typename K , typename T >
identity_transducer_helper< S, K, T >::ret | extension (const Element< S, T > &)
| Extend an automaton to a transducer.
template<typename SA , typename TA , typename ST , typename TT >
Element< ST, TT > | extension (const Element< SA, TA > &, const Element< ST, TT > &)
| Extend an automaton to a transducer.
template<typename A , typename AI >
void | factor_here (const Element< A, AI > &a)
| Make every states of the automaton initial and final states (in place).
template<typename A , typename AI >
Element< A, AI > | factor (const Element< A, AI > &a)
| Make every states of the automaton initial and final states.
template<typename S , typename T , typename Ss , typename Ts >
void | finite_support_convert (Element< S, T > &dst, const Element< Ss, Ts > &org)
| Finite support conversion.
template<class S , class T >
output_projection_helper< S, T > ::ret | image (const Element< S, T > &)
template<typename SA , typename TA , typename M >
void | partial_elimination (const Element< SA, TA > &a, M &state_exp_pair)
| This function computes a set of expression, after having eliminated all states which are not initial or final.
template<typename S1 , typename T1 , typename S2 , typename T2 , typename M >
void | partial_evaluation (const Element< S1, T1 > &E, const Element< S2, T2 > &S, const typename Element< S2, T2 >::hstate_t &p, M &res)
| Partial evaluation of a K RatExp E over a realtime transducer S, starting from a given state p.
template<typename A , typename T >
bool | has_successors (const Element< A, T > &a, const typename automaton_traits< T >::hstate_t s)
| Whether a state has successors.
template<typename A , typename T >
bool | has_predecessors (const Element< A, T > &a, const typename automaton_traits< T >::hstate_t s)
| Whether a state has predecessors.
template<typename A , typename T >
void | invert (const Element< A, T > &t, Element< A, T > &res)
| Invert a transducer.
template<typename A , typename T >
Element< A, T > & | invert (const Element< A, T > &t)
| Invert a transducer.
template<typename A , typename AI >
bool | is_ambiguous (const Element< A, AI > &aut)
| Test the ambiguity of automaton.
template<typename A , typename AI >
bool | is_deterministic (const Element< A, AI > &a)
| Test if an automaton is deterministic.
template<typename A , typename AI >
bool | is_empty (const Element< A, AI > &a)
| Evaluate if an automaton is empty.
template<typename S , typename A >
bool | is_ltl (const Element< S, A > &t)
| Test whether an FMP transducer is letter-to-letter.
template<typename S , typename A >
bool | is_normalized_transducer (const Element< S, A > &t)
| Test the normalization of transducer.
template<typename A , typename AI >
bool | is_trim (const Element< A, AI > &a)
| Return true is all states are reachable and co-reachable.
template<typename A , typename AI >
bool | is_useless (const Element< A, AI > &a)
| Return true if the automaton has no successful computation.
template<typename A , typename T >
bool | are_isomorphic (const Element< A, T > &a, const Element< A, T > &b)
| Returns true if the two automata are isomorphic.
template<class Series , class T , class Letter >
Element< Series, T > | cderivate (const Element< Series, T > &exp, Letter a)
| The c-derivative of the krat expression w.r.t to a letter.
template<class Series , class T , class Word >
Element< Series, T > | word_cderivate (const Element< Series, T > &exp, Word a)
| The c-derivative of the krat expression w.r.t to a word.
template<class Series , class T >
std::pair< typename Element < Series, T >::semiring_elt_t, bool > | constant_term (const Element< Series, T > &exp)
| Return the constant term of the krat expression.
template<class Series , class T , class Letter >
std::pair< Element< Series, T > , bool > | derivate (const Element< Series, T > &exp, Letter a)
| The antimirov derivative of the krat expression w.r.t to a letter.
template<class Series , class T , class Word >
std::pair< Element< Series, T > , bool > | word_derivate (const Element< Series, T > &exp, Word a)
| The antimirov derivative of the krat expression w.r.t to a word.
template<class Series , class T >
std::list< typename Series::monoid_t::alphabet_t::letter_t > | flatten (const Element< Series, T > &exp)
| This algorithm extracts the letters from a rational expression.
template<class Series , class T >
linearize_element< Series, T > ::element_t | linearize (const Element< Series, T > &exp)
| The linearization of the krat expression.
template<class Series , class T , class Letter >
std::pair< std::set< Element < Series, T > >, bool > | partial_derivate (const Element< Series, T > &exp, Letter a)
| The partial derivative of the krat expression w.r.t to a letter.
template<class S , class T >
Element< S, T > | letter_to_letter_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Undocumented.
template<typename A , typename AI >
Element< A, AI > | minimization_hopcroft (const Element< A, AI > &a)
| Return the minimal automaton using the hopcroft algorithm.
template<typename A , typename AI >
Element< A, AI > | quotient (const Element< A, AI > &a)
| Return the quotient of a non-deterministic acceptor.
template<typename A , typename AI >
Element< A, AI > | minimization_moore (const Element< A, AI > &a)
| Returns the minimal deterministic automaton associated to the input one.
template<typename A , typename AI >
Element< A, AI > | co_minimization_moore (const Element< A, AI > &a)
| Returns the co-minimal co-deterministic automaton associated to the input one.
template<typename A , typename AI >
void | minimization_moore_here (Element< A, AI > &a)
| Minimalize the deterministic input automaton.
template<typename A , typename AI >
void | co_minimization_moore_here (Element< A, AI > &a)
| Co-minimalize the co-deterministic input automaton.
template<typename A , typename AI >
Element< A, AI > | normalize (const Element< A, AI > &a)
| Return the fresh thompson-normalized automaton.
template<typename A , typename AI >
void | normalize_here (Element< A, AI > &a)
| In-place normalize to the thompson form.
template<typename A , typename AI >
bool | is_normalized (const Element< A, AI > &a)
| Return true if the input automaton is thompson-normalized.
template<typename A , typename AI1 , typename AI2 >
void | union_of_normalized_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Do the in-place union of two thompson-normalized automata.
template<typename A , typename AI1 , typename AI2 >
Element< A, AI1 > | union_of_normalized (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Return the fresh union of two thompson-normalized automata.
template<typename A , typename AI1 , typename AI2 >
void | concatenate_of_normalized_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Do the in-place concatenation of two thompson-normalized automata.
template<typename A , typename AI1 , typename AI2 >
Element< A, AI1 > | concatenate_of_normalized (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Return the fresh concatenation of two thompson-normalized automata.
template<typename A , typename AI >
void | star_of_normalized_here (Element< A, AI > &a)
| Do in-place star transformation on the thompson-normalized input.
template<typename A , typename AI >
Element< A, AI > | star_of_normalized (const Element< A, AI > &a)
| Return the fresh star transformation of its normalized input.
template<typename S , typename T >
void | compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S , typename T >
Element< S, T > | compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S , typename T >
void | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S , typename T >
Element< S, T > | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S , typename M1 , typename M2 , typename lhs_t , typename rhs_t , typename res_t >
void | do_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
| Ambiguous composition.
template<typename S , typename M1 , typename M2 , typename lhs_t , typename rhs_t , typename res_t >
void | do_u_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
| Unambiguous composition.
template<typename A , typename AI , typename EPS >
void | one_eps_closure (Element< A, AI > &a, const EPS &eps, misc::direction_type dir=misc::backward)
| In place one_eps_closure of an automaton (default is backward eps_closure).
template<typename A , typename AI , typename EPS >
void | backward_one_eps_closure (Element< A, AI > &a, const EPS &eps)
| In place backward_one_eps_closure of an automaton.
template<typename A , typename AI , typename EPS >
void | forward_one_eps_closure (Element< A, AI > &a, const EPS &eps)
| In place forward one_eps_closure of an automaton.
template<typename A , typename AI >
void | prefix_here (const Element< A, AI > &a)
| Make every states of the automaton final states (in place).
template<typename A , typename AI >
Element< A, AI > | prefix (const Element< A, AI > &a)
| Make every states of the automaton final states.
template<typename auto_t , typename trans_t >
void | set_states (const trans_t &, auto_t &, std::map< typename trans_t::hstate_t, typename auto_t::hstate_t > &)
template<typename A , typename AI >
void | realtime_here (Element< A, AI > &a, misc::direction_type dir)
| Modify an automaton in place to make it realtime.
template<typename A , typename AI >
Element< A, AI > | realtime (const Element< A, AI > &a, misc::direction_type dir)
| Create a realtime automaton from another one.
template<typename S , typename T >
Element< S, T > | realtime (const Element< S, T > &e)
| Compute the realtime version of a rational expression or an automata.
template<typename S , typename T >
void | realtime_here (Element< S, T > &e)
| Modify a rational expression or automata in place to make it realtime.
template<typename S , typename T >
bool | is_realtime (const Element< S, T > &e)
| Test whether an automaton or a rational expression is realtime.
template<typename A , typename AI >
Element< A, AI > | reduce (const Element< A, AI > &a, misc::direction_type dir=misc::right_left)
| Reduce of an automaton (default right_left).
template<typename A , typename AI >
Element< A, AI > | semi_reduce (const Element< A, AI > &a)
| Semi reduction of an automaton.
template<typename S , typename T >
void | rw_composition (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Composition for Rational-Weight transducers.
template<typename S , typename T >
Element< S, T > | rw_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Composition for Rational-Weight transducers.
template<typename InputIterator , typename FoundFunctor , typename Series , typename Kind , typename T >
void | search (const Element< Automata< Series, Kind >, T > &a, const InputIterator &begin, const InputIterator &end, typename Element< Automata< Series, Kind >, T >::letter_t eol, FoundFunctor &f)
| Search for a rational expression into a text.
template<typename Series , typename Kind , typename T , typename StatesSet >
static unsigned int | compute_distances (const Element< Automata< Series, Kind >, T > &a, std::vector< StatesSet > &distances)
| Compute distances from initial states to final states.
template<typename InputIterator , typename Series , typename Kind , typename T , typename StatesSet >
static std::pair< bool, unsigned int > | window_backsearch (const misc::Window< InputIterator, typename Element< Automata< Series, Kind >, T >::letter_t > &w, const Element< Automata< Series, Kind >, T > &a, const std::vector< StatesSet > &distances)
| Back search inside a window.
template<typename InputIterator , typename FoundFunctor , typename Series , typename Kind , typename T >
static InputIterator | confirm_and_report_match (const misc::Window< InputIterator, typename Element< Automata< Series, Kind >, T >::letter_t > &w, const Element< Automata< Series, Kind >, T > &a, FoundFunctor &f)
| Finds the longest match of a starting from w, and report it to the functor.
template<typename Automaton >
Automaton::monoid_elt_t | shortest (const Automaton &autom)
| Return the smallest accepted word.
template<typename Automaton , typename MonoidElt >
bool | shortest (const Automaton &autom, MonoidElt &word)
| Compute the smallest accepted word.
template<typename Automaton , typename MonoidElt , typename Alloc >
void | enumerate (const Automaton &autom, unsigned max_length, std::list< MonoidElt, Alloc > &word_list)
| Compute the list of short accepted words.
template<typename A , typename AI1 , typename AI2 >
void | union_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| In place union of two automata.
template<typename A , typename AI1 , typename AI2 >
Element< A, AI1 > | union_ (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Union of two automata.
template<typename A , typename AI >
bool | is_standard (const Element< A, AI > &a)
| Returns true iff the input automaton is standard.
template<typename A , typename AI >
void | standardize (Element< A, AI > &a)
| Returns a standard automaton associated to the input.
template<typename A , typename AI1 , typename AI2 >
void | sum_of_standard_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| In-place sum of two standard automata.
template<typename A , typename AI1 , typename AI2 >
Element< A, AI1 > | sum_of_standard (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Return a fresh sum of two standard automata.
template<typename A , typename AI1 , typename AI2 >
void | concat_of_standard_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| In-place concatenation of two standard automata.
template<typename A , typename AI1 , typename AI2 >
Element< A, AI1 > | concat_of_standard (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
| Return a fresh concatenation of two standard automata.
template<typename A , typename AI >
void | star_of_standard_here (Element< A, AI > &a)
| In-place star transformation of a standard automaton.
template<typename A , typename AI >
Element< A, AI > | star_of_standard (const Element< A, AI > &a)
| Return the fresh star transformation of a standard automata.
template<typename A , typename AI >
void | left_mult_of_standard_here (Element< A, AI > &aut, const typename Element< A, AI >::series_set_elt_t &k)
| In-place left exterior multiplication by a weight.
template<typename A , typename AI >
void | right_mult_of_standard_here (Element< A, AI > &aut, const typename Element< A, AI >::series_set_elt_t &k)
| In-place right exterior multiplication by a weight.
template<typename A , typename T , typename Exp >
void | standard_of (Element< A, T > &a, const Exp &e)
| Convert a rational expression into a standard automaton.
template<typename A , typename AI , typename HStatesSet >
Element< A, AI > | sub_automaton (const Element< A, AI > &a, const HStatesSet &s, bool check_states=true)
| Returns a fresh automaton that is the sub-automaton defined by a set.
template<typename A , typename AI , typename HStatesSet >
void | sub_automaton_here (Element< A, AI > &a, const HStatesSet &s, bool check_states=true)
| Select a sub-automaton into a given automaton.
template<class S , class T >
Element< S, T > | sub_normalize (const Element< S, T > &a)
| Sub-normalize a FMP transducer.
template<class S , class T1 , class T2 >
void | sub_normalize (const Element< S, T1 > &a, Element< S, T2 > &res)
| Sub-normalize a FMP transducer.
template<class S , class T >
void | sub_normalize_here (Element< S, T > &a)
| Sub-normalize a FMP transducer, in place version.
template<class S , class T >
bool | is_sub_normalized (const Element< S, T > &a)
| Check if a FMP transducer is sub-normalized.
template<typename A , typename AI >
void | suffix_here (const Element< A, AI > &a)
| Make every states of the automaton initial states (in place).
template<typename A , typename AI >
Element< A, AI > | suffix (const Element< A, AI > &a)
| Make every states of the automaton initial states.
template<typename A , typename T , typename Letter , typename Weight >
void | thompson_of (Element< A, T > &out, const rat::exp< Letter, Weight > &kexp)
| The Thompson automaton associated to the krat expression.
template<typename AutoType , typename S , typename K , class T >
Element< Automata< S, K > , AutoType > | thompson_of (const Element< S, T > &exp)
| The Thompson automaton associated to the krat expression.
template<typename A , typename AI1 , typename AI2 >
void | transpose (Element< A, AI1 > &dst, const Element< A, AI2 > &src)
| Transposition of an automaton.
template<typename A , typename AI >
Element< A, AI > | transpose (const Element< A, AI > &src)
| Return a fresh transposed automaton.
template<typename A , typename AI >
std::set< typename Element< A, AI >::hstate_t > | useful_states (const Element< A, AI > &a)
| Returns a useful states of the automaton.
template<typename A , typename AI >
Element< A, AI > | trim (const Element< A, AI > &a)
| Return a fresh automaton in which non useful states are removed.
template<typename A , typename AI >
void | trim_here (Element< A, AI > &a)
| Trim a.
template<typename lhs_t , typename rhs_t , typename F >
void | auto_translate_transitions (lhs_t &dst, const rhs_t &from, const F &translate_fun)
template<typename S , typename T >
bool | op_contains (const Structure< S > &set, const T &value)
| Check whether a value is contained in a set.
template<typename S , typename T , typename U >
bool | op_eq (const Structure< S > &, const T &v1, const U &v2)
| Equality between two structured values.
template<typename S , typename V , typename T , typename U >
bool | op_eq (const Structure< S > &, const Structure< V > &, const T &v1, const U &v2)
| Equality between two structured values.
template<typename S , typename T , typename U >
bool | op_lt (const Structure< S > &, const T &v1, const U &v2)
| Ordered comparison between two structured values.
template<typename S , typename V , typename T , typename U >
bool | op_lt (const Structure< S > &, const Structure< V > &, const T &v1, const U &v2)
| Ordered comparison between two structured values.
template<typename S , typename R , typename T >
R | op_convert (const Structure< S > &se, SELECTOR(R), const T &data)
| Default conversion between value types with computation.
template<typename S , typename T >
const T & | op_convert (const Structure< S > &se, SELECTOR(T), const T &from_data)
| Pass-through conversion.
template<typename S , typename T >
const T & | op_convert (const Structure< S > &se, SELECTOR(T), const Structure< S > &from_se, const T &from_data)
| Pass-through conversion between compatible structures.
template<typename S , typename T >
T | op_default (const Structure< S > &se, SELECTOR(T))
| Default construction of values using `Structure`.
template<typename S , typename T >
void | op_swap (const Structure< S > &se, T &v1, T &v2)
| Default swap operator.
template<typename S , typename T , typename U >
void | op_assign (const Structure< S > &s, T &dst, const U &src)
| Assignement operator between two implementations of a Structure<S>.
template<typename S , typename T , typename U >
void | op_assign (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &src)
| Assignement operator between two implementations of two differents structures.
template<typename S , typename T , typename U >
void | op_in_add (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
| Addition in place operator between two different elements.
template<typename S , typename T , typename U >
void | op_in_sub (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
| Substraction in place operator between two different elements.
template<typename S , typename T , typename U >
void | op_in_mul (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
| Multiplication in place operator between two different elements.
template<typename S , typename T , typename U >
void | op_in_div (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
| Division in place operator between two different elements.
template<typename S , typename T , typename U >
void | op_in_mod (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
| Modulo in place operator between two different elements.
template<typename S , typename T , typename U >
T | op_add (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
| Addition operator between two different elements.
template<typename S , typename T , typename U >
T | op_sub (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
| Substraction operator between two different elements.
template<typename S , typename T , typename U >
T | op_mul (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
| Multiplication operator between two different elements.
template<typename S , typename T , typename U >
T | op_div (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
| Division operator between two different elements.
template<typename S , typename T , typename U >
T | op_mod (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
| Modulo operator between two different elements.
template<typename S , typename St , typename T >
St & | op_rin (const Structure< S > &s, St &st, const T &v)
| Input stream operator.
template<typename S , typename St , typename T >
St & | op_rout (const Structure< S > &s, St &st, const T &v)
| Output stream operator.
template<typename S1 , typename T1 , typename S2 , typename T2 >
static bool | operator< (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S1 , typename T1 , typename S2 , typename T2 >
static bool | operator> (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S1 , typename T1 , typename S2 , typename T2 >
static bool | operator<= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S1 , typename T1 , typename S2 , typename T2 >
static bool | operator>= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Comparison between Element instances.
template<typename S , typename T , typename U >
static bool | operator< (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename S , typename T , typename U >
static bool | operator> (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename S , typename T , typename U >
static bool | operator>= (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename S , typename T , typename U >
static bool | operator<= (const vcsn::Element< S, T > &e, const U &v)
| Comparison between Element and foreign values (left version).
template<typename U , typename S , typename T >
static bool | operator< (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename U , typename S , typename T >
static bool | operator> (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename U , typename S , typename T >
static bool | operator>= (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename U , typename S , typename T >
static bool | operator<= (const U &v, const vcsn::Element< S, T > &e)
| Comparison between Element and foreign values (right version).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static bool | operator== (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Equality between Element instances.
template<typename S , typename T , typename U >
static bool | operator== (const vcsn::Element< S, T > &e, const U &v)
| Equality between Element and foreign values (left version).
template<typename U , typename S , typename T >
static bool | operator== (const U &v, const vcsn::Element< S, T > &e)
| Equality between Element and foreign values (right version).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static bool | operator!= (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Difference between Element instances.
template<typename S , typename T , typename U >
static bool | operator!= (const vcsn::Element< S, T > &e, const U &v)
| Difference between Element and foreign values (left version).
template<typename U , typename S , typename T >
static bool | operator!= (const U &v, const vcsn::Element< S, T > &e)
| Difference between Element and foreign values (right version).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static vcsn::op_add_traits< S1, S2, T1, T2 >::ret_t | operator+ (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Addition between Element instances.
template<typename S , typename T , typename U >
static vcsn::Element< S, T > | operator+ (const vcsn::Element< S, T > &e, const U &v)
| Addition between Element and foreign values (left).
template<typename U , typename S , typename T >
static vcsn::Element< S, T > | operator+ (const U &v, const vcsn::Element< S, T > &e)
| Addition between Element and foreign values (right).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static vcsn::op_sub_traits< S1, S2, T1, T2 >::ret_t | operator- (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Substraction between Element instances.
template<typename S , typename T , typename U >
static vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &e, const U &v)
| Substraction between Element and foreign values (left).
template<typename U , typename S , typename T >
static vcsn::Element< S, T > | operator- (const U &v, const vcsn::Element< S, T > &e)
| Substraction between Element and foreign values (right).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static vcsn::op_mul_traits< S1, S2, T1, T2 >::ret_t | operator* (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Multiplication between Element instances.
template<typename S , typename T , typename U >
static vcsn::Element< S, T > | operator* (const vcsn::Element< S, T > &e, const U &v)
| Multiplication between Element and foreign values (left).
template<typename U , typename S , typename T >
static vcsn::Element< S, T > | operator* (const U &v, const vcsn::Element< S, T > &e)
| Multiplication between Element and foreign values (right).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static vcsn::op_div_traits< S1, S2, T1, T2 >::ret_t | operator/ (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Division between Element instances.
template<typename S , typename T , typename U >
static vcsn::Element< S, T > | operator/ (const vcsn::Element< S, T > &e, const U &v)
| Division between Element and foreign values (left).
template<typename U , typename S , typename T >
static vcsn::Element< S, T > | operator/ (const U &v, const vcsn::Element< S, T > &e)
| Division between Element and foreign values (right).
template<typename S1 , typename T1 , typename S2 , typename T2 >
static vcsn::op_mod_traits< S1, S2, T1, T2 >::ret_t | operator% (const vcsn::Element< S1, T1 > &e1, const vcsn::Element< S2, T2 > &e2)
| Modulus between Element instances.
template<typename S , typename T , typename U >
static vcsn::Element< S, T > | operator% (const vcsn::Element< S, T > &e, const U &v)
| Modulus between Element and foreign values (left).
template<typename U , typename S , typename T >
static vcsn::Element< S, T > | operator% (const U &v, const vcsn::Element< S, T > &e)
| Modulus between Element and foreign values (right.
template<typename S , typename T >
static vcsn::Element< S, T > | operator- (const vcsn::Element< S, T > &)
| Unary negation of Element instances.
template<typename St , typename S , typename T >
static St & | operator<< (St &s, const vcsn::Element< S, T > &e)
| Output to stream.
template<typename St , typename S , typename T >
static St & | operator>> (St &s, const vcsn::Element< S, T > &e)
| Input from stream.
Determinization algorithms
template<typename A , typename AI >
Element< A, AI > | determinize (const Element< A, AI > &a)
| Build a deterministic automaton from a Boolean automaton.
template<typename A , typename AI >
Element< A, AI > | determinize (const Element< A, AI > &a, std::map< typename Element< A, AI >::hstate_t, std::set< typename Element< A, AI >::hstate_t > > &m)
| Build a deterministic automaton from a Boolean automaton, keeping trace of state-to-states correspondences.
FMP automaton to rational weight transducer algorithm.
Compute the equivalent Rational Weight transducer of a FMP automaton. Please note that for the moment this function works only if the support of each transition is finite. Algorithm : If the FMP contains transitions with "complex" expression (E), i.e. infinite support, then Thompson of E. With the resulting automaton apply a conversion. i.e. (a,x) -> a|x
template<typename S , typename T , typename SS , typename TT >
Element< SS, TT > & | fmp_to_rw (const Element< S, T > &fmp, Element< SS, TT > &res)
Infiltration algorithm

Returns a fresh automaton that is the infiltration of the two input ones.

Precondition:
  The two input automata must be realtime.

template<typename A , typename T , typename U >
Element< A, T > | infiltration (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 > | infiltration (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< typename T::hstate_t, std::pair< typename T::hstate_t, typename U::hstate_t > > &, const bool use_geometry=false)
Letter-to-letter FMP automaton to pair letter automaton algorithm.
Compute the pair letter automaton associated to an ltl FMP automaton.
template<typename S , typename T >
void | ltl_to_pair (const Element< S, T > &ltl, typename mute_ltl_to_pair< S, T >::ret &res)
template<typename S , typename T >
mute_ltl_to_pair< S, T >::ret | ltl_to_pair (const Element< S, T > &ltl)
Pair letter automaton to FMP transducer algorithm.
Compute the FMP transducer associated to a pair letter automaton.
template<typename S , typename T >
void | pair_to_fmp (const Element< S, T > &aut, typename mute_pair_to_fmp< S, T >::ret &res)
template<typename S , typename T >
mute_pair_to_fmp< S, T >::ret | pair_to_fmp (const Element< S, T > &aut)
Product algorithm

Returns a fresh automaton that is the product of the two input ones.

Precondition:
  The two input automata must be realtime.

template<typename A , typename T , typename U >
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, const bool use_geometry=false)
template<typename A , typename T , typename U >
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< typename T::hstate_t, std::pair< typename T::hstate_t, typename U::hstate_t > > &, const bool use_geometry=false)
Rational Weight transducer to FMP automaton conversion
template<typename S , typename T , typename SS , typename TT >
Element< SS, TT > & | rw_to_fmp (const Element< S, T > &trans, Element< SS, TT > &res)
| Compute the equivalent FMP automaton of a Rational Weight transducer.
Shuffle algorithm

Returns a fresh automaton that is the shuffle of the two input ones.

Precondition:
  The two input automata must be realtime.

template<typename A , typename T , typename U >
Element< A, T > | shuffle (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 > | shuffle (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< typename T::hstate_t, std::pair< typename T::hstate_t, typename U::hstate_t > > &, const bool use_geometry=false)
Default operation on automata.
template<typename S , typename R , typename T >
R | op_convert (const AutomataBase< S > &se, SELECTOR(R), const T &data)
| Default conversion between value types with computation.
template<typename S , typename T >
const T & | op_convert (const AutomataBase< S > &, SELECTOR(T), const T &from_data)
| Default conversion between value types with computation.
template<typename S , typename T , typename U >
void | op_assign (const AutomataBase< S > &s, T &dst, const U &src)
| Assignement operator between two implementations of a Structure<S>.
template<typename S , typename T >
void | op_assign (const AutomataBase< S > &concept, T &dst, const T &src)
| Default conversion between value types with computation.
template<class S , class T >
const automaton_traits< T > ::tag_t & | op_get_tag (const AutomataBase< S > &, const T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::tag_t & | op_get_tag (const AutomataBase< S > &, T &)
| Default conversion between value types with computation.
template<class S , class T >
const automaton_traits< T > ::geometry_t & | op_get_geometry (const AutomataBase< S > &, const T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::geometry_t & | op_get_geometry (const AutomataBase< S > &, T &)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_exists (const AutomataBase< S > &s, const T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::states_t | op_states (const AutomataBase< S > &, const T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::hstate_t | op_get_state (const AutomataBase< S > &, const T &, int state)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::transitions_t | op_transitions (const AutomataBase< S > &, const T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::initial_support_t | op_initial (const AutomataBase< S > &, const T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::final_support_t | op_final (const AutomataBase< S > &, const T &)
| Default conversion between value types with computation.
template<class S , class T >
void | op_set_initial (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, T >::series_set_elt_t &s)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_is_initial (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state)
| Default conversion between value types with computation.
template<class S , class T >
void | op_set_final (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, T >::series_set_elt_t &s)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_is_final (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &state)
| Default conversion between value types with computation.
template<class S , class T >
void | op_set_initial (const AutomataBase< S > &, T &, int state, const typename Element< S, T >::series_set_elt_t &s)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const T &, int state)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_is_initial (const AutomataBase< S > &, const T &, int state)
| Default conversion between value types with computation.
template<class S , class T >
void | op_set_final (const AutomataBase< S > &, T &, int state, const typename Element< S, T >::series_set_elt_t &s)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const T &, int state)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_is_final (const AutomataBase< S > &, const T &, int state)
| Default conversion between value types with computation.
template<class S , class T >
void | op_clear_initial (const AutomataBase< S > &, T &)
| Default conversion between value types with computation.
template<class S , class T >
void | op_clear_final (const AutomataBase< S > &, T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::hstate_t | op_add_state (const AutomataBase< S > &, T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::hstate_t | op_choose_state (const AutomataBase< S > &, T &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::label_t &label)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_weighted_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::semiring_elt_t &w, const typename Element< S, T >::monoid_elt_value_t &m)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_series_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::series_set_elt_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_spontaneous (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::semiring_elt_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_letter_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::letter_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::label_t &label)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_weighted_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::semiring_elt_t &w, const typename Element< S, T >::monoid_elt_value_t &m)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_series_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::series_set_elt_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_spontaneous (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::semiring_elt_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T > ::htransition_t | op_add_letter_transition (const AutomataBase< S > &, T &, int from, int to, const typename Element< S, T >::letter_t &)
| Default conversion between value types with computation.
template<class S , class T >
void | op_update (const AutomataBase< S > &, T &, const typename automaton_traits< T >::htransition_t &, const typename Element< S, T >::label_t &l)
| Default conversion between value types with computation.
template<class S , class T >
void | op_del_state (const AutomataBase< S > &, T &, const typename automaton_traits< T >::hstate_t &)
| Default conversion between value types with computation.
template<class S , class T >
void | op_del_state (const AutomataBase< S > &, T &, int)
| Default conversion between value types with computation.
template<class S , class T >
void | op_del_transition (const AutomataBase< S > &, T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_has_state (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::hstate_t &)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_has_state (const AutomataBase< S > &, const T &, int)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_has_transition (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::hstate_t | op_src_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
automaton_traits< T >::hstate_t | op_dst_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::label_t | op_label_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
const Element< S, T > ::series_set_elt_t | op_series_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T > ::series_set_elt_value_t | op_series_value_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::monoid_elt_t | op_word_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::semiring_elt_t | op_weight_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::monoid_elt_value_t | op_word_value_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, T >::letter_t | op_letter_of (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
bool | op_is_spontaneous (const AutomataBase< S > &, const T &, const typename automaton_traits< T >::htransition_t &)
| Default conversion between value types with computation.
template<class S , class T >
Element< S, TransposeView< T > > | transpose_view (Element< S, T > &)
| This function creates a transposed view of an automaton.
template<class S , class T >
const Element< S, TransposeView< T > > | transpose_view (const Element< S, T > &)
| This function creates a transposed view of an automaton.
template<class S , class T >
automaton_traits < TransposeView< T > >::initial_support_t | op_initial (const AutomataBase< S > &, const TransposeView< T > &)
| Operations on automata implemented with TransposeView.
template<class S , class T >
automaton_traits < TransposeView< T > >::final_support_t | op_final (const AutomataBase< S > &, const TransposeView< T > &)
| Operations on automata implemented with TransposeView.
template<class S , class T >
void | op_set_initial (const AutomataBase< S > &, TransposeView< T > &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, TransposeView< T > >::series_set_elt_t &s)
| Operations on automata implemented with TransposeView.
template<class S , class T >
Element< S, TransposeView< T > >::series_set_elt_t | op_get_initial (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::hstate_t &)
| Operations on automata implemented with TransposeView.
template<class S , class T >
void | op_set_final (const AutomataBase< S > &, TransposeView< T > &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, T >::series_set_elt_t &s)
| Operations on automata implemented with TransposeView.
template<class S , class T >
Element< S, T >::series_set_elt_t | op_get_final (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::hstate_t &state)
| Operations on automata implemented with TransposeView.
template<class S , class T >
void | op_clear_initial (const AutomataBase< S > &, TransposeView< T > &)
| Operations on automata implemented with TransposeView.
template<class S , class T >
void | op_clear_final (const AutomataBase< S > &, TransposeView< T > &)
| Operations on automata implemented with TransposeView.
template<class S , class T >
automaton_traits< T >::hstate_t | op_src_of (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::htransition_t &)
| Operations on automata implemented with TransposeView.
template<class S , class T >
automaton_traits< T >::hstate_t | op_dst_of (const AutomataBase< S > &, const TransposeView< T > &, const typename automaton_traits< T >::htransition_t &)
| Operations on automata implemented with TransposeView.
Inequality operator for Structures.
Calls equality operator of sub-class.
template<typename S >
bool | operator!= (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b)

## Detailed Description

The main namespace of the Vaucanson library.

## 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 130 of file free_monoid.hh.

## Function Documentation

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

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 |
| ) |  |  |

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< T_auto, S, T >::delta(), and BerrySethiAlgo< T_auto, S, T >::is_final().

bool is_cut_up | ( | const Element< A, AI > & | a | ) |

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< A, AI > cut_up | ( | const Element< A, AI > & | a | ) |

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

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 160 of file cut_up.hxx.

References Element< S, T >::structure().

Referenced by cut_up_here().

void cut_up | ( | const Element< A, AI > & | a,
|  | Element< A, AI > & | res |
| ) |  |  |

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 150 of file cut_up.hxx.

References SELECT, and Element< S, T >::structure().

void cut_up_here | ( | Element< A, AI > & | a | ) |

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

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 170 of file cut_up.hxx.

References cut_up().

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

Definition at line 285 of file image.hxx.

References Element< S, T >::structure().

bool has_successors | ( | const Element< A, T > & | a,
|  | const typename automaton_traits< T >::hstate_t | s |
| ) |  |  |

Whether a state has successors.

Parameters:

  | a | Automaton.
  | s | State.

Returns:
  True is the state s has successors.

Definition at line 26 of file has_neighbour.hxx.

References Element< S, T >::value().

bool has_predecessors | ( | const Element< A, T > & | a,
|  | const typename automaton_traits< T >::hstate_t | s |
| ) |  |  |

Whether a state has predecessors.

Parameters:

  | a | Automaton.
  | s | State.

Returns:
  True is the state s has predecessors.

Definition at line 37 of file has_neighbour.hxx.

References Element< S, T >::value().

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

Invert a transducer.

Parameters:

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

Element<A, T>& vcsn::invert | ( | const Element< A, T > & | t | ) |

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 |
| ) |  |  |

Ambiguous composition.

Works only for boolean transducers.

Definition at line 337 of file normalized_composition.hxx.

References compose(), and eps_removal_here().

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

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().

Element< A, AI > reduce | ( | const Element< A, AI > & | a,
|  | misc::direction_type | dir = `misc::right_left` |
| ) |  |  |

Reduce of an automaton (default right_left).

This algorithm computes the reduce representation of an automaton with weights in a division ring.

A technical report about this algorithm is available here : http://www.lrde.epita.fr/cgi-bin/twiki/view/Publications/200901-Seminar-Delmon Proof and explanations are also available in ETA Chapter 3, Sec 4.3

Parameters:

  | a | The weighted automaton to reduce.
  | dir | The order in which reductions are computed.

Precondition:
  The automaton a must be realtime.
  The weights of the automaton a must be defined in a division ring.

See also:
  semi_reduce()

Author:
  Vivien Delmon, Sylvain Lombardy

Definition at line 302 of file reduce.hxx.

References is_realtime(), Element< S, T >::structure(), transpose(), and transpose_view().

Element< A, AI > semi_reduce | ( | const Element< A, AI > & | a | ) |

Semi reduction of an automaton.

This algorithm computes the (left) semi reduction of an automaton with weights in a division ring.

A technical report about this algorithm is available here : http://www.lrde.epita.fr/cgi-bin/twiki/view/Publications/200901-Seminar-Delmon Proof and explanations are also available in ETA Chapter 3, Sec 4.3

Parameters:

  | a | The weighted automaton to reduce.
  | dir | The order in which reductions are computed.

Precondition:
  The automaton a must be realtime.
  The weights of the automaton a must be defined in a division ring.

See also:
  reduce()

Author:
  Vivien Delmon, Sylvain Lombardy

Definition at line 292 of file reduce.hxx.

References is_realtime(), and Element< S, T >::structure().

void auto_translate_transitions | ( | lhs_t & | dst,
|  | const rhs_t & | from,
|  | const F & | translate_fun |
| ) |  |  |

Bug:
  Write documentation and tests.

Definition at line 27 of file translate.hxx.

Element< S, TransposeView< T > > transpose_view | ( | Element< S, T > & | a | ) |

This function creates a transposed view of an automaton.

See also:
  transpose(), TransposeView

Definition at line 48 of file transpose_view.hxx.

References Element< S, T >::structure(), and Element< S, T >::value().

Referenced by reduce(), and transpose().

const Element< S, TransposeView< T > > transpose_view | ( | const Element< S, T > & | a | ) |

This function creates a transposed view of an automaton.

See also:
  transpose(), TransposeView

Definition at line 56 of file transpose_view.hxx.

References Element< S, T >::structure(), and Element< S, T >::value().

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

Operations on automata implemented with TransposeView.

Definition at line 276 of file transpose_view.hxx.

References op_final().

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

Operations on automata implemented with TransposeView.

Definition at line 283 of file transpose_view.hxx.

References op_initial().

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

Operations on automata implemented with TransposeView.

Definition at line 290 of file transpose_view.hxx.

References op_set_final().

Element< S, TransposeView< T > >::series_set_elt_t op_get_initial | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | const typename automaton_traits< T >::hstate_t & | state |
| ) |  |  |

Operations on automata implemented with TransposeView.

Definition at line 299 of file transpose_view.hxx.

References op_get_final().

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

Operations on automata implemented with TransposeView.

Definition at line 310 of file transpose_view.hxx.

References op_set_initial().

Element< S, T >::series_set_elt_t op_get_final | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | const typename automaton_traits< T >::hstate_t & | state |
| ) |  |  |

Operations on automata implemented with TransposeView.

Definition at line 319 of file transpose_view.hxx.

References op_get_initial().

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

Operations on automata implemented with TransposeView.

Definition at line 331 of file transpose_view.hxx.

References op_clear_final().

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

Operations on automata implemented with TransposeView.

Definition at line 338 of file transpose_view.hxx.

References op_clear_initial().

automaton_traits< T >::hstate_t op_src_of | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | const typename automaton_traits< T >::htransition_t & | e |
| ) |  |  |

Operations on automata implemented with TransposeView.

Definition at line 345 of file transpose_view.hxx.

References op_dst_of().

automaton_traits< T >::hstate_t op_dst_of | ( | const AutomataBase< S > & | s,
|  | const TransposeView< T > & | v,
|  | const typename automaton_traits< T >::htransition_t & | e |
| ) |  |  |

Operations on automata implemented with TransposeView.

Definition at line 354 of file transpose_view.hxx.

References op_src_of().