vcsn Namespace Reference

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

Classes
struct	op_star_traits
	Meta information about the return type of the star operation. 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	linearize_element
	The types of a linearized expression. More...
struct	FindBestSearch
	Specific implementation for search(). More...
struct	WindowedBackSearch
	Specific implementation for search(). More...
struct	dynamic_traits< Automata< Series > >
	Dynamic traits for automata. More...
struct	MetaElement< Automata< Series >, T >
	MetaElement specialization for automata. More...
struct	virtual_types< Automata< Series > >
	Virtual types for automata. More...
struct	AutomataBase
	It symbolises the set of automata with multiplicity over a fixed semiring and a fixed free monoid. More...
struct	MetaElement< AutomataBase< Self >, T >
	MetaElement<AutomataBase<Self>, T> defines the interface of every automaton that is the result of the interaction of a structural element (AutomataBase<Self>) and an implementation T. More...
class	AutoKind< labels_are_series, Self, Series, SeriesT, LabelT >
	AutoKind adds methods to automaton adapted to the kind of label that are held by the internal data structure. More...
struct	dynamic_traits< Transducer< Series > >
	Dynamic traits for transducers. More...
struct	MetaElement< Transducer< Series >, T >
	Specialization of MetaElement for transducers. More...
struct	virtual_types< Transducer< Series > >
	Virtual types for transducers. More...
class	Transducer
	This is the final class for the set of transducers. More...
struct	TransducerBase
	It denotes the set of transducer with multiplicity over a fixed semiring and a fixed free couple of monoid. More...
struct	MetaElement< TransducerBase< Self >, T >
	MetaElement<TransducerBase<Self>, T> defines the interface of every transducer that is the result of the interaction of a structural element (TransducerBase<Self>) and an implementation T. More...
struct	geometry
	Store 4 maps for geometry properties of the automaton. states_ map is used to store states coordinates. edges_ map is used to store the label position for edges. initials_ map is used to store the label position for initial transitions. finals_ map is used to store the label position for final transitions. 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
	This class provides the standard operator delegations to Element. More...
class	MetaElement
	Parent class of Element. More...
struct	dynamic_traits< algebra::AlphabetSetBase< S > >
	Specialization of dynamic_traits for AlphabetSetBase. More...
struct	virtual_types< algebra::AlphabetSetBase< S > >
	Specialization of virtual_types for AlphabetSetBase. More...
struct	MetaElement< algebra::AlphabetSetBase< S >, T >
	Specialization of MetaElement for AlphabetSetBase. More...
struct	MetaElement< algebra::FreeMonoidBase< Self >, T >
	Element of a free monoid i.e. words. More...
struct	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	MetaElement< algebra::FreeMonoidProductBase< Self >, T >
	Element of a monoid i.e. words. More...
struct	MetaElement< algebra::MonoidBase< Self >, T >
	Defines services of element of every monoid. More...
struct	dynamic_traits< algebra::NumericalSemiring >
	Meta information about then NumericalSemiring structural element. More...
struct	MetaElement< algebra::NumericalSemiring, T >
	Services of Element for numerical semirings. More...
struct	MetaElement< algebra::SemigroupBase< Self >, T >
	Services of every element of a semigroup. More...
struct	MetaElement< algebra::SemiringBase< Self >, T >
	Services of every element of semiring (semiring_elt). More...
class	MetaElement< algebra::SeriesBase< Self >, T >
	Services of every series. More...
struct	dynamic_traits< algebra::TropicalSemiring< TropicalKind > >
	Meta information about the tropical semirings. More...
struct	MetaElement< algebra::TropicalSemiring< TropicalKind >, T >
	Services of element of a tropical semiring. More...
struct	dynamic_traits< algebra::AlphabetSet< L > >
	meta information about AlphabetSet. More...
struct	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	MetaElement< algebra::AlphabetSet< L >, algebra::AlphabetDecorator< L, T > >
	Services of every alphabet implemented with AlphabetDecorator<T>. More...
struct	MetaElement< algebra::AlphabetSet< L >, std::set< L > >
	Services of every alphabet implemented with std::set. More...
Namespaces
namespace	algebra
	Namespace for algebra constructs in Vaucanson.
namespace	rat
namespace	algorithm_patterns
namespace	geom
namespace	delta_kind
namespace	history
namespace	boolean_automaton
namespace	boolean_transducer
namespace	fmp_transducer
namespace	r_automaton
namespace	tools
namespace	io
namespace	xml
namespace	z_automaton
namespace	z_fmp_transducer
namespace	z_max_plus_automaton
namespace	z_min_plus_automaton
namespace	z_transducer
Determinization algorithms
template<typename A, typename T>
Element< A, T >	determinize (const Element< A, T > &a)
	Returns the determinized of a Boolean automaton.
template<typename A, typename T>
Element< A, T >	determinize (const Element< A, T > &a, std::map< hstate_t, std::set< hstate_t > > &)
	Returns the determinized of a Boolean automaton.
FMP automaton to realtime transducer algorithm.
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > &	fmp_to_realtime (const Element< S, T > &fmp, Element< SS, TT > &res)
	Compute the equivalent transducer of a FMP automaton.
Product algorithm
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)
	Returns a fresh automaton that is the product of the two input ones.
template<typename A, typename T, typename U>
Element< A, T >	product (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< hstate_t, std::pair< hstate_t, hstate_t > > &, const bool use_geometry=false)
	Returns a fresh automaton that is the product of the two input ones.
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.
[NOHEADER]
Element< S, TransposeView< T > >	transpose_view (Element< S, T > &)
	This function creates a transposed view of an automaton.
[NOHEADER]
template<class S, class T>
automaton_traits< TransposeView< T > >::initial_support_t	op_initial (const AutomataBase< S > &, const TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
automaton_traits< TransposeView< T > >::final_support_t	op_final (const AutomataBase< S > &, const TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_set_initial (const AutomataBase< S > &, TransposeView< T > &, hstate_t state, const typename Element< S, TransposeView< T > >::series_set_elt_t &s)
	Operations on automata implemented with TransposeView.
template<class S, class T>
Element< S, TransposeView< T > >::series_set_elt_t	op_get_initial (const AutomataBase< S > &, const TransposeView< T > &, hstate_t)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_set_final (const AutomataBase< S > &, TransposeView< T > &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
	Operations on automata implemented with TransposeView.
template<class S, class T>
Element< S, T >::series_set_elt_t	op_get_final (const AutomataBase< S > &, const TransposeView< T > &, hstate_t state)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_clear_initial (const AutomataBase< S > &, TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_clear_final (const AutomataBase< S > &, TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
hstate_t	op_origin_of (const AutomataBase< S > &, const TransposeView< T > &, hedge_t)
	Operations on automata implemented with TransposeView.
template<class S, class T>
hstate_t	op_aim_of (const AutomataBase< S > &, const TransposeView< T > &, hedge_t)
	Operations on automata implemented with TransposeView.
Inequality operator for Structures
This operator calls equality operator of sub-class.
template<typename S>
bool	operator!= (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b)
Typedefs
typedef utility::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...
enum	realtime_type
	Enum to indicate which kind of realtime algorithms must be used.
Functions
template<typename S, typename St, typename T>
St &	op_rout (const algebra::AlphabetSetBase< S > &s, St &st, const T &a)
	Implementation of generic stream output operator for alphabets.
template<typename S, typename T, typename L>
bool	op_letter_equality (const algebra::AlphabetSetBase< S > &s, const T &a, L lhs, L rhs)
	Implementation of generic letter equality modulo meta-characters.
template<typename S, typename T>
Element< S, T >	mirror (const Element< S, T > &e)
	Return a fresh word that is the mirror.
template<typename S, typename T, typename CharContainer>
bool	parse_word (Element< S, T > &dest, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped=CharContainer())
	Parse the beginning of the string looking for a word.
template<typename S, typename T>
op_star_traits< S, T >::ret_t	star (const Element< S, T > &w)
	Returns a fresh weight that is the star of w.
template<typename S, typename T>
bool	parse_weight (Element< S, T > &w, const std::string &, typename std::string::const_iterator &)
	Parse the beginning of the string looking for a weight.
template<typename S, typename T>
bool	starable (const Element< S, T > &elt)
	Returns true if we can compute the star of the weight.
template<typename S, typename T>
bool	op_can_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T))
	Returns whether a non-starable Element can be choosen from a Semiring.
template<typename S, typename T>
Element< S, T >	op_choose_starable (const algebra::SemiringBase< S > &set, SELECTOR(T))
	Returns a random starable element in the set.
template<typename S, typename T>
Element< S, T >	op_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T))
	Returns a random non-starable element in the set.
template<typename S, typename T>
Element< S, T >	transpose (const algebra::SeriesBase< S > &s, const T &t)
	returns a fresh series that is the transposed of the argument.
template<typename S, typename T>
bool	is_letter_support (const Element< S, T > &s)
	Returns true if the support of the series is only composed of letters.
template<typename S1, typename S2, typename T1, typename T2>
void	extract_support (Element< S1, T1 > &, Element< S2, T2 > &)
	Make the first series be the support of the second.
template<class S, class T>
Element< S, T >	hadamard (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Return the hadamard product of lhs and rhs.
template<typename W, typename M, typename Tm, typename Tw>
bool	op_contains (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_mul (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst, const rat::exp< Tm, Tw > &arg)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_in_mul (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &ret, const oTw &w)
template<typename W, typename M, typename oTw, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_mul (const W &semiring, const algebra::Series< W, M > &s, const oTw &w, const rat::exp< Tm, Tw > &b)
template<typename A, typename T>
std::set< hstate_t >	accessible_states (const Element< A, T > &a)
	Return accessible states.
template<typename A, typename T>
Element< A, T >	accessible (const Element< A, T > &a)
	Extract the sub-automaton composed of accessible states.
template<typename A, typename T>
void	accessible_here (Element< A, T > &a)
	In-place extract the sub-automaton of accessible states.
template<typename A, typename T>
std::set< hstate_t >	coaccessible_states (const Element< A, T > &a)
	Return co-accessible states.
template<typename A, typename T>
Element< A, T >	coaccessible (const Element< A, T > &a)
	Extract the sub-automaton composed of co-accessible states.
template<typename A, typename T>
void	coaccessible_here (Element< A, T > &a)
	In-place extract the sub-automaton of co-accessible states.
template<class Series, class T>
Element< Series, T >	canonical (const Element< Series, T > &exp)
	Transform a krat expression into its canonical form, following aci-rules.
template<typename A, typename T>
Element< A, T >::series_set_elt_t	aut_to_exp (const Element< A, T > &a)
	Returns a series which describes the language of the automaton.
template<typename A, typename T, typename Chooser_>
Element< A, T >::series_set_elt_t	aut_to_exp (const Element< A, T > &a, const Chooser_ &c)
	Returns a series which describes the language of the automaton.
template<typename A, typename T>
void	backward_realtime_here (Element< A, T > &a)
	In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T >	backward_realtime (const Element< A, T > &a)
	Returns a fresh realtime automaton.
template<typename A, typename T, typename Exp>
void	berry_sethi (Element< A, T > &, const Exp &)
	Build an automaton from an expression using the Berry-Sethi construction.
template<typename S, typename T>
linearize_element< S, T >::alphabet_t	linearized_alphabet (const Element< S, T > &exp)
	Computes a linearized alphabet from a rational expression.
template<typename Exp, typename Letter>
Exp	linear_exp_continuation (const Exp &exp, const Letter &l)
	This function computes a continuation on linearized expressions.
template<typename A, typename T, typename Exp>
void	brzozowski (Element< A, T > &, const Exp &)
	Build an automaton from an expression using the Brzozowski construction.
template<typename A, typename T>
void	closure_here (Element< A, T > &a, bool bck=true)
	In place closure of an automaton (default is backward closure).
template<typename A, typename T>
Element< A, T >	closure (const Element< A, T > &a, bool bck=true)
	Closure of an automaton (default is backward closure).
template<typename A, typename T>
void	backward_closure_here (Element< A, T > &a)
	In place backward closure of an automaton.
template<typename A, typename T>
Element< A, T >	backward_closure (const Element< A, T > &a)
	Backward closure of an automaton.
template<typename A, typename T>
void	forward_closure_here (Element< A, T > &a)
	In place forward closure of an automaton.
template<typename A, typename T>
Element< A, T >	forward_closure (const Element< A, T > &a)
	Forward closure of an automaton.
template<class A_, typename Auto>
void	do_closure_here (const AutomataBase< A_ > &, Auto &a, bool bck_fwd)
template<typename A, typename T>
void	complement_here (Element< A, T > &a)
	Complement in place the set of final states.
template<typename A, typename T>
Element< A, T >	complement (const Element< A, T > &a)
	Complement the set of final states.
template<typename A, typename T>
void	complete_here (Element< A, T > &a)
	Make the transition function of an automaton total w.r.t alphabet.
template<typename A, typename T>
Element< A, T >	complete (const Element< A, T > &a)
	Make the transition function of an automaton total w.r.t alphabet.
template<class A, class T>
bool	is_complete (const Element< A, T > &a)
	Test if the transition function is complete for each state.
template<class A, class T>
Element< A, T >	concatenate (const Element< A, T > &lhs, const Element< A, T > &rhs)
	Return the concatenation of two automata.
template<class A, class T>
void	concatenate_here (Element< A, T > &lhs, const Element< A, T > &rhs)
	In place concatenation of two automata.
template<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>
bool	is_deterministic (const Element< A, T > &a)
	Test if an automaton is deterministic.
template<typename A, typename input_t, typename output_t>
void	do_determinize (const AutomataBase< A > &a_set, output_t &output, const input_t &input, std::map< hstate_t, std::set< hstate_t > > &m)
template<typename A, typename T, typename W>
Element< A, T >::semiring_elt_t	eval (const Element< A, T > &a, const W &word)
	Return the image of a word by an automaton.
template<typename A, typename T, typename W>
Element< A, T >::semiring_elt_t	eval (const Element< A, T > &a, const W &word, bool &b_ret)
	Return the image of a word by an automaton.
template<typename SA, typename TA, typename ST, typename TT, typename SARET, typename TARET>
void	evaluation (const Element< SA, TA > &, const Element< ST, TT > &, Element< SARET, TARET > &)
	Evaluate for a "letterized" automaton and a realtime transducer.
template<typename 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<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	b_composition (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
	Composition for unweighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
Element< S, T >	b_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Composition for unweighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
void	normalized_composition (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
	Composition for normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
Element< S, T >	normalized_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Composition for normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename M1, typename M2, typename Auto_t>
Auto_t	do_outsplitting (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const Auto_t &aut, std::set< hstate_t > &m)
	Separate states considering their output: a|1 on one state, 1|x and a|x on the other.
template<typename S, typename M1, typename M2, typename Auto_t>
Auto_t	do_insplitting (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const Auto_t &aut, std::set< hstate_t > &m)
	Separate states considering their input: 1|x on one state, a|1 and a|x on the other.
template<typename A, typename T>
void	realtime_here (Element< A, T > &a, realtime_type type)
	In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T >	realtime (const Element< A, T > &a, realtime_type type)
	Returns a fresh realtime automaton.
template<typename S, typename T>
void	realtime_composition (const Element< S, T > &, const Element< S, T > &, Element< S, T > &)
	Composition for realtime transducers.
template<typename S, typename T>
Element< S, T >	realtime_composition (const Element< S, T > &, const Element< S, T > &)
	Composition for realtime transducers.
template<typename S, typename T>
Element< S, T >	realtime (const Element< S, T > &e)
	Calls the do_realtime function for rational expression or automata.
template<typename S, typename T>
void	realtime_here (Element< S, T > &e)
	Calls the do_realtime_here function for rational expression or automata.
template<typename S, typename T>
bool	is_realtime (const Element< S, T > &e)
	Test whether an automaton or a regular expression is realtime.
template<class InputIterator, class FoundFunctor, class Series, class T>
void	search (const Element< Automata< Series >, T > &a, const InputIterator &begin, const InputIterator &end, typename Element< Automata< Series >, T >::letter_t eol, FoundFunctor &f)
	Search for a rational expression into a text.
template<class Series, class T, class StatesSet>
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 utility::Window< InputIterator, typename Element< Automata< Series >, T >::letter_t > &w, const Element< Automata< Series >, T > &a, const std::vector< StatesSet > &distances)
	Back search inside a window.
template<class InputIterator, class FoundFunctor, class Series, class T>
static InputIterator	confirm_and_report_match (const utility::Window< InputIterator, typename Element< Automata< Series >, T >::letter_t > &w, const Element< Automata< Series >, T > &a, FoundFunctor &f)
	Finds the longest match of a starting from w, and report it to the functor.
template<typename A, typename T>
void	standardize (Element< A, T > &a)
	Returns a standard automaton associated to the input.
template<typename A, typename T>
bool	is_standard (const Element< A, T > &a)
	Returns true if the input automaton is standard.
template<typename A, typename T, typename U>
void	union_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In-place union of two standard automata.
template<typename A, typename T, typename U>
Element< A, T >	union_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return a fresh union of two standard automata.
template<typename A, typename T, typename U>
void	concat_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In-place concatenation of two standard automata.
template<typename A, typename T, typename U>
Element< A, T >	concat_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return a fresh concatenation of two standard automata.
template<typename A, typename T>
void	star_of_standard_here (Element< A, T > &a)
	In-place star transformation of a standard automata.
template<typename A, typename T>
Element< A, T >	star_of_standard (const Element< A, T > &a)
	Return the fresh star transformation of a standard automata.
template<typename A, typename T, typename Exp>
void	standard_of (Element< A, T > &a, const Exp &e)
	Convert a rational expression into a standard automaton.
template<typename A, typename T, typename Exp>
Element< A, T >	standard_of (const Exp &e)
	Convert a rational expression into a standard automaton.
template<typename A, typename T, typename StatesSet>
Element< A, T >	sub_automaton (const Element< A, T > &a, const StatesSet &s, bool check_states=true)
	Returns a fresh automaton that is the sub-automaton defined by a set.
template<typename A, typename T, typename StatesSet>
void	sub_automaton_here (Element< A, T > &a, const StatesSet &s, bool check_states=true)
	Select a sub-automaton into a given automaton.
template<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>
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<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k)
	Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k)
	Delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k)
	Store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k)
	Store the output edges of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::edges k)
	Delta using a query, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::edges k)
	Delta on a letter, with container output.
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k)
	Store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	Delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k)
	Store the output states of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	Delta using a quesry, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	Delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k)
	Store the output edges of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k)
	Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::edges k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::edges k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::edges k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k)
	Store the output states of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k)
	store the output edges of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k)
	store the output edges of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k)
	store the output edges of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k)
	store the output edges of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k)
	store the output edges of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k)
	store the output edges of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k)
	store the output edges of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k)
	store the output edges of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output edges of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k)
	Delta with a query and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k)
	Delta on a letter with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	Store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	Store the output edges of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k)
	Delta with a query and container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k)
	Delta on a letter with container output.
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	Delta with no condition and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	Delta on a letter with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	Delta without condition, container output.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	Delta with a query, using container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	Delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	Reverse delta without condition, and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::edges k)
	Reverse delta with query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::edges k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	Reverse delta on a container, with no condition.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::edges k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::edges k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::edges k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	Reverse delta on a container, with no conditions.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	Reverse delta in a container, with a query.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	Reverse delta in a container, on a letter.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<typename S, typename T>
bool	op_contains (const Structure< S > &set, const T &value)
	Check whether a value is contained in a set.
template<typename S, typename T, typename U>
bool	op_eq (const Structure< S > &, const T &v1, const U &v2)
	Equality between two structured values.
template<typename S, typename V, typename T, typename U>
bool	op_eq (const Structure< S > &, const Structure< V > &, const T &v1, const U &v2)
	Equality between two structured values.
template<typename S, typename T, typename U>
bool	op_lt (const Structure< S > &, const T &v1, const U &v2)
	Ordered comparison between two structured values.
template<typename S, typename V, typename T, typename U>
bool	op_lt (const Structure< S > &, const Structure< V > &, const T &v1, const U &v2)
	Ordered comparison between two structured values.
template<typename S, typename R, typename T>
R	op_convert (const Structure< S > &se, SELECTOR(R), const T &data)
	Default conversion between value types with computation.
template<typename S, typename T>
const T &	op_convert (const Structure< S > &se, SELECTOR(T), const T &from_data)
	Pass-through conversion.
template<typename S, typename T>
const T &	op_convert (const Structure< S > &se, SELECTOR(T), const Structure< S > &from_se, const T &from_data)
	Pass-through conversion between compatible structures.
template<typename S, typename T>
T	op_default (const Structure< S > &se, SELECTOR(T))
	Default construction of values using Structure.
template<typename S, typename T>
void	op_swap (const Structure< S > &se, T &v1, T &v2)
	Default swap operator.
template<typename S, typename T, typename U>
void	op_assign (const Structure< S > &s, T &dst, const U &src)
	Assignement operator between two implementations of a Structure<S>.
template<typename S, typename T, typename U>
void	op_assign (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &src)
	Assignement operator between two implementations of two differents structures.
template<typename S, typename T, typename U>
void	op_in_add (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
	Addition in place operator between two different elements.
template<typename S, typename T, typename U>
void	op_in_sub (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
	Substraction in place operator between two different elements.
template<typename S, typename T, typename U>
void	op_in_mul (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
	Multiplication in place operator between two different elements.
template<typename S, typename T, typename U>
void	op_in_div (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
	Division in place operator between two different elements.
template<typename S, typename T, typename U>
void	op_in_mod (const Structure< S > &s1, const Structure< S > &s2, T &dst, const U &arg)
	Modulo in place operator between two different elements.
template<typename S, typename T, typename U>
T	op_add (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
	Addition operator between two different elements.
template<typename S, typename T, typename U>
T	op_sub (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
	Substraction operator between two different elements.
template<typename S, typename T, typename U>
T	op_mul (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
	Multiplication operator between two different elements.
template<typename S, typename T, typename U>
T	op_div (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
	Division operator between two different elements.
template<typename S, typename T, typename U>
T	op_mod (const Structure< S > &s1, const Structure< S > &s2, const T &v1, const U &v2)
	Modulo operator between two different elements.
template<typename S, typename St, typename T>
St &	op_rin (const Structure< S > &s, St &st, const T &v)
	Input stream operator.
template<typename S, typename St, typename T>
St &	op_rout (const Structure< S > &s, St &st, const T &v)
	Output stream operator.
template<typename S1, typename T1, typename S2, typename T2>
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.

---

Detailed Description

The main namespace of the Vaucanson library.

---

Function Documentation

bool op_contains (  const algebra::Series< W, M > &  , const rat::exp< Tm, Tw > &  )

Bug: FIXME Operators in krat.hxx are of the form: template<typename S, typename M ...> ... op(Series<S>& series, M& monoid, ...) and should be instead: template<typename S, typename M ...> ... op(Series<S>& series, Monoid<M>& monoid, ...)

void op_in_mul (  const algebra::Series< W, M > &  s, rat::exp< Tm, Tw > &  dst, const rat::exp< Tm, Tw > &  arg )

Bug: FIXME: Add the following transformation in a separated function.

void op_in_mul (  const algebra::Series< W, M > &  s, const W &  semiring, rat::exp< Tm, Tw > &  ret, const oTw &  w )

Bug: FIXME: Add the following transformation in a separated function.

rat::exp< Tm, Tw > op_mul (  const W &  semiring, const algebra::Series< W, M > &  s, const oTw &  w, const rat::exp< Tm, Tw > &  b )

Bug: FIXME: Add the following transformation in a separated function.

linearize_element<S, T>::alphabet_t 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()

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

void do_closure_here (  const AutomataBase< A_ > &  , Auto &  a, bool  bck_fwd )

Bug: FIXME: This converters should be removed

bool is_cut_up (  const Element< S, T > &  a  )

Check if labels are series with one element. a Input automaton. Returns: is cut-up.

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

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

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

void do_determinize (  const AutomataBase< A > &  a_set, output_t &  output, const input_t &  input, std::map< hstate_t, std::set< hstate_t > > &  m )

Bug: FIXME: for the moment, it uses subset_construction and trim but it must be rewritten to do the twice at the same time more efficiently.

Element< S, T > sub_normalize (  const Element< S, T > &  a  )

Sub-normalize a FMP transducer. a Input automaton. Returns: Sub-normalized automaton.

void sub_normalize (  const Element< S, T1 > &  a, Element< S, T2 > &  res )

Sub-normalize a FMP transducer. a Input automaton. res Output automaton.

bool is_sub_normalized (  const Element< S, T > &  a  )

Check if a FMP transducer is sub-normalized. a Input automaton. Returns: boolean.

void op_delta (  const AutomataBase< S > &  , const TransposeView< T > &  , OutputIterator  res, hstate_t  from, const L &  query, delta_kind::edges  k )

Delta with a query and iterator output. Store the output edges of the state 'from' where query(label(e)) is true using 'res'.

void op_letter_delta (  const AutomataBase< S > &  , const TransposeView< T > &  , OutputIterator  res, hstate_t  from, const L &  letter, delta_kind::edges  k )

Delta on a letter with iterator output. Store the output edges of the state 'from' where the label matches the letter.

void op_deltac (  const AutomataBase< S > &  , const TransposeView< T > &  , Container &  res, hstate_t  from, const L &  query, delta_kind::edges  k )

Delta with a query and container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'.

void op_letter_deltac (  const AutomataBase< S > &  , const TransposeView< T > &  , Container &  res, hstate_t  from, const L &  letter, delta_kind::edges  k )

Delta on a letter with container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'.

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. Store the output states of the state 'from' using 'res'.

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. Store the output states of the state 'from' where query(label(e)) is true using 'res'.

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. Store the output states of the state 'from' where the label matches the letter.

void op_deltac (  const AutomataBase< S > &  , const TransposeView< T > &  , Container &  res, hstate_t  from, delta_kind::states  k )

Delta without condition, container output. Store the output states of the state 'from' in the container 'res'.

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. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'.

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. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'.

void op_rdelta (  const AutomataBase< S > &  , const TransposeView< T > &  , OutputIterator  res, hstate_t  from, delta_kind::edges  k )

Reverse delta without condition, and iterator output. Store the output edges of the state 'from' using 'res'.

void op_rdelta (  const AutomataBase< S > &  , const TransposeView< T > &  , OutputIterator  res, hstate_t  from, const L &  query, delta_kind::edges  k )

Reverse delta with query, with iterator output. Store the output edges of the state 'from' where query(label(e)) is true using 'res'.

void op_letter_rdelta (  const AutomataBase< S > &  , const TransposeView< T > &  , OutputIterator  res, hstate_t  from, const L &  letter, delta_kind::edges  k )

Reverse delta on a letter, with iterator output. Store the output edges of the state 'from' where the label matches the letter.

void op_rdeltac (  const AutomataBase< S > &  , const TransposeView< T > &  , Container &  res, hstate_t  from, delta_kind::edges  k )

Reverse delta on a container, with no condition. Store the output edges of the state 'from' in the container 'res'.

void op_rdeltac (  const AutomataBase< S > &  , const TransposeView< T > &  , Container &  res, hstate_t  from, const L &  query, delta_kind::edges  k )

Reverse delta using a query, with container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'.

void op_letter_rdeltac (  const AutomataBase< S > &  , const TransposeView< T > &  , Container &  res, hstate_t  from, const L &  letter, delta_kind::edges  k )

Reverse delta on a letter, with container output. Store the output edges of the state 'from' where query(label(e)) is true in the container 'res'.

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. Store the output states of the state 'from' where query(label(e)) is true using 'res'.

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. Store the output states of the state 'from' where the label matches the letter.

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. Store the output states of the state 'from' in the container 'res'

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. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'

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. Store in the container 'res' the output states of the state 'from' where query(label(e)) is true.

---