vcsn Namespace Reference
[Miscellaneous constructs used by Vaucanson]

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

Classes
struct	op_star_traits
	Meta information about the return type of the star operation. More...
class	IsFiniteAppMatcher
class	SupportMatcher
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	HChooser
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	DerivativesAlgo
struct	delta_functor
class	EpsilonRemover
class	Finder
class	EpsilonRemover< A_, Auto, bool >
class	EpsilonRemoverSp
struct	eval_functor
struct	KRatExpInitialDerivation
	Visitor to have an initial set of partial derivatives terms from an expression. More...
struct	reference_type
struct	reference_type< true, T >
struct	iterator_type
struct	iterator_type< true, T >
struct	PartialExp
class	PRatExpDerivationVisitor
	This class performs partial rational expression derivations. More...
class	Skeleton
class	Trie
class	Isomorpher
class	ConstantTermEval
	This is the visitor that really computes the constant term. More...
struct	KRatExpDerivation
struct	KRatExpFlatten
struct	linearize_element
	The types of a linearized expression. More...
struct	KRatExpLinearize
struct	mute_ltl_to_pair
struct	composer
class	Product
struct	FindBestSearch
	Specific implementation for search(). More...
struct	WindowedBackSearch
	Specific implementation for search(). More...
class	ThompsonVisitor
struct	dynamic_traits< Automata< Series > >
	Dynamic traits for automata. More...
struct	MetaElement< Automata< Series >, T >
	MetaElement specialization for automata. More...
struct	virtual_types< Automata< Series > >
	Virtual types for automata. More...
class	Automata
	Final class for the set of automata. More...
struct	projection_traits< Automata< S >, T >
struct	AutomataBase
	It symbolises the set of automata with multiplicity over a fixed semiring and a fixed free monoid. More...
struct	automaton_traits
struct	generalized_traits
struct	standard_of_traits
struct	projection_traits
struct	mute_graph_impl_traits
struct	mute_graph_impl_monoid_traits
struct	virtual_types< AutomataBase< S > >
struct	dynamic_traits< AutomataBase< S > >
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...
struct	labels_are_letters
struct	labels_are_words
struct	labels_are_series
struct	labels_are_couples
struct	LabelOf< labels_are_letters, WordValue, WeightValue, SeriesValue, Letter >
struct	LabelOf< labels_are_series, WordValue, WeightValue, SeriesValue, Letter >
struct	LabelOf< labels_are_couples, WordValue, WeightValue, SeriesValue, Letter >
struct	LabelOf< labels_are_words, WordValue, WeightValue, SeriesValue, Letter >
struct	always_true
class	letter_query
class	spontaneous_query
struct	state_h
struct	transition_h
class	handler
class	AutoKind
struct	ls_delta_letter_query
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	lc_delta_letter_query
class	AutoKind< labels_are_couples, Self, Series, SeriesT, LabelT >
struct	label_h
class	SmartLabel
class	SmartLabelContainer
struct	SmartLabel_ref_dec
struct	SmartLabel_ref_inc
struct	NoTag
struct	dynamic_traits< Transducer< Series > >
	Dynamic traits for transducers. More...
struct	MetaElement< Transducer< Series >, T >
	Specialization of MetaElement for transducers. More...
struct	virtual_types< Transducer< Series > >
	Virtual types for transducers. More...
class	Transducer
	Final class for the set of transducers. More...
struct	input_projection_helper
struct	input_projection_helper< Transducer< S >, T >
struct	input_projection_helper< Automata< S >, T >
struct	output_projection_helper
struct	output_projection_helper< Transducer< S >, T >
struct	output_projection_helper< Automata< S >, T >
struct	identity_transducer_helper
struct	TransducerBase
	The most general concept of transducer. More...
struct	transducer_traits
	Traits for transducer implementation. More...
struct	extension_traits
struct	input_projection_traits
struct	fmp_input_projection_traits
struct	output_projection_traits
struct	fmp_output_projection_traits
struct	virtual_types< TransducerBase< S > >
struct	dynamic_traits< TransducerBase< S > >
struct	MetaElement< TransducerBase< Self >, T >
	Services of every element of the transducer set. More...
class	IdentityView
struct	automaton_traits< IdentityView< T > >
struct	geometry
	Store 4 maps for geometry properties of the automaton. More...
class	handler< Tag, unsigned >
struct	TransposeView
	Provides a transposed view of an automaton. More...
struct	transpose_traits
	Traits for TransposeView. More...
struct	transpose_traits< Element< S, T > >
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...
class	DefaultFactoryError
class	Factory
struct	MetaElement< Structure< S >, T >
	The base class that glues structural elements to implementation values. More...
struct	default_slot_tag
struct	undefined_type
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...
struct	op_begin_traits
struct	op_rbegin_traits
struct	dynamic_traits< algebra::AlphabetSetBase< S > >
	Specialization of dynamic_traits for AlphabetSetBase. More...
struct	virtual_types< algebra::AlphabetSetBase< S > >
	Specialization of virtual_types for AlphabetSetBase. More...
struct	MetaElement< algebra::AlphabetSetBase< S >, T >
	Specialization of MetaElement for AlphabetSetBase. More...
struct	dynamic_traits< algebra::FreeMonoidBase< Self > >
struct	virtual_types< algebra::FreeMonoidBase< S > >
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	representation_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	virtual_types< algebra::FreeMonoidProduct< F, S > >
struct	dynamic_traits< algebra::FreeMonoidProductBase< Self > >
struct	representation_traits< algebra::FreeMonoidProductBase< Self > >
struct	virtual_types< algebra::FreeMonoidProductBase< S > >
struct	MetaElement< algebra::FreeMonoidProductBase< Self >, T >
	Element of a monoid i.e. words. More...
struct	dynamic_traits< algebra::MonoidBase< Self > >
struct	virtual_types< algebra::MonoidBase< S > >
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	virtual_types< algebra::NumericalSemiring >
struct	MetaElement< algebra::NumericalSemiring, T >
	Services of Element for numerical semirings. More...
struct	dynamic_traits< algebra::SemigroupBase< Self > >
struct	virtual_types< algebra::SemigroupBase< S > >
struct	MetaElement< algebra::SemigroupBase< Self >, T >
	Services of every element of a semigroup. More...
struct	dynamic_traits< algebra::SemiringBase< Self > >
struct	virtual_types< algebra::SemiringBase< S > >
struct	MetaElement< algebra::SemiringBase< Self >, T >
	Services of every element of semiring (semiring_elt). More...
struct	dynamic_traits< algebra::SeriesBase< Self > >
struct	virtual_types< 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	virtual_types< algebra::TropicalSemiring< TropicalKind > >
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	virtual_types< algebra::FreeMonoid< A > >
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	transducer_traits< bmig::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	input_projection_traits< bmig::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	fmp_input_projection_traits< bmig::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	output_projection_traits< bmig::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	fmp_output_projection_traits< bmig::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	extension_traits< bmig::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	automaton_traits< bmig::Graph< labels_are_letters, WordValue, bool, SeriesValue, Letter, Tag, GeometryCoords > >
struct	transducer_traits< listg::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	input_projection_traits< listg::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	fmp_input_projection_traits< listg::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	output_projection_traits< listg::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	fmp_output_projection_traits< listg::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	extension_traits< listg::Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, GeometryCoords > >
struct	MetaElement< algebra::AlphabetSet< L >, std::set< L > >
	Services of every alphabet implemented with std::set. More...
struct	MetaElement< algebra::AlphabetSet< L >, algebra::AlphabetDecorator< L, T > >
	Services of every alphabet implemented with AlphabetDecorator<L, T>. More...
struct	MetaElement< algebra::Series< W, M >, rat::exp< Tm, Tw > >
struct	op_add_traits< M, algebra::Series< W, M >, oTm, rat::exp< Tm, Tw > >
struct	op_add_traits< W, algebra::Series< W, M >, oTw, rat::exp< Tm, Tw > >
struct	op_mul_traits< W, algebra::Series< W, M >, oTw, rat::exp< Tm, Tw > >
struct	op_add_traits< M, algebra::Series< W, M >, oTm, algebra::polynom< Tm, Tw > >
struct	op_add_traits< W, algebra::Series< W, M >, oTw, algebra::polynom< Tm, Tw > >
struct	op_mul_traits< W, algebra::Series< W, M >, oTw, algebra::polynom< Tm, Tw > >
struct	MetaElement< algebra::Series< W, M >, algebra::polynom< Tm, Tw > >
class	handler< state_h, boost::shared_ptr< std::size_t > >
Namespaces
namespace	algebra
	Namespace for algebra constructs in Vaucanson.
namespace	misc
	The namespace for miscellaneous constructs.
namespace	rat
namespace	algorithm_patterns
namespace	internal
namespace	splitting
namespace	delta_kind
	These are helpers for delta functions: transition or state oriented delta are chosen according to them.
namespace	history
namespace	VCSN_GRAPH_IMPL
namespace	bmig
namespace	listg
namespace	tools
namespace	xml
Enumerations
enum	op_choose_max_word_length_t
	Maximum length of words generated by op_choose. More...
Functions
template<typename S, typename T>
Element< S, T >	mirror (const Element< S, T > &e)
	Return a fresh word that is the mirror.
template<typename S, typename T, typename CharContainer>
bool	parse_word (Element< S, T > &dest, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped=CharContainer())
	Parse the beginning of the string looking for a word.
template<typename S, typename T>
const std::basic_string< T > &	op_convert (const algebra::FreeMonoidBase< S > &s, SELECTOR(std::basic_string< T >), const std::basic_string< T > &from_data)
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<class A, typename AI>
std::set< typename Element< A, AI >::hstate_t >	do_accessible_states (const AutomataBase< A > &, const Element< A, AI > &a)
template<class A, typename AI>
std::set< typename Element< A, AI >::hstate_t >	do_coaccessible_states (const AutomataBase< A > &, const Element< A, AI > &a)
template<typename S, typename SI>
Element< S, SI >	canonical (const Element< S, SI > &exp)
	Transform a krat expression into its canonical form, following aci-rules.
template<typename S, typename SI>
Element< S, SI >	do_canonical (const algebra::SeriesBase< S > &, const Element< S, SI > &exp)
template<typename S, typename T>
void	do_first_projection (const Element< S, T > &src, typename projection_traits< S, T >::first_projection_t &dst)
template<typename S, typename T>
void	do_second_projection (const Element< S, T > &src, typename projection_traits< S, T >::second_projection_t &dst)
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<class A, typename AI, typename Chooser>
Element< A, AI >::series_set_elt_t	do_in_aut_to_exp (const AutomataBase< A > &a_set, Element< A, AI > &a, Chooser chooser)
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 T_auto, typename S, typename T>
T_auto *	do_berry_sethi (const T_auto &out, const Element< S, T > &kexp)
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 T_auto, typename Exp>
T_auto *	do_brzozowski (const T_auto &out, const Exp &kexp)
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 S, typename M1, typename M2, typename Auto_t>
void	do_composition_cover (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const Auto_t &fmp, Auto_t &ret)
template<typename S, typename M1, typename M2, typename Auto_t>
void	do_composition_co_cover (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const Auto_t &fmp, Auto_t &ret)
template<typename A, typename AI>
Element< A, AI >	concatenate (const Element< A, AI > &lhs, const Element< A, AI > &rhs)
	Return the concatenation of two automata.
template<typename A, typename AI>
void	concatenate_here (Element< A, AI > &lhs, const Element< A, AI > &rhs)
	In place concatenation of two automata.
template<typename A, typename AI>
void	do_auto_in_concat (const AutomataBase< A > &, Element< A, AI > &lhs, const Element< A, AI > &rhs)
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 S, typename T, typename TT, typename Auto, typename Ret>
void	do_cut_up (const AutomataBase< S > &, const rat::exp< T, TT > &, const Auto &a, Ret &res)
template<typename S, typename T, typename TT, typename Auto, typename Ret>
void	do_cut_up (const S &, const algebra::polynom< T, TT > &, const Auto &a, Ret &res)
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>
void	broken_derived_term_automaton (Element< A, T > &a, const Exp &e)
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 T_auto, typename S, typename T>
T_auto *	do_derived_term_automaton (const T_auto &out, const Element< S, T > &kexp)
template<typename T_auto, typename S, typename T>
T_auto *	do_broken_derived_term_automaton (const T_auto &out, const Element< S, T > &kexp)
template<typename A, typename input_t, typename output_t>
void	do_subset_construction (const AutomataBase< A > &, output_t &output, const input_t &input, std::map< typename output_t::hstate_t, std::set< typename input_t::hstate_t > > &m=std::map< typename output_t::hstate_t, std::set< typename input_t::hstate_t > >())
template<typename A, typename AI>
Element< A, AI >	subset_construction (const Element< A, AI > &a)
template<typename A, typename AI>
void	do_determinize (const AutomataBase< A > &a_set, Element< A, AI > &output, const Element< A, AI > &input, std::map< typename Element< A, AI >::hstate_t, std::set< typename Element< A, AI >::hstate_t > > &m)
template<typename src_t, typename dst_t>
void	do_fmp_domain (const src_t &src, dst_t &dst)
template<typename src_t, typename dst_t>
void	do_rw_domain (const src_t &src, dst_t &dst)
template<typename S, typename S2, typename T, typename T2>
void	domain_dispatch (const AutomataBase< S > &, const Element< S, T > &src, Element< S2, T2 > &dst)
template<typename S, typename S2, typename T, typename T2>
void	domain_dispatch (const TransducerBase< S > &, const Element< S, T > &src, Element< S2, T2 > &dst)
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<class A_, typename Auto, typename Weight>
void	do_eps_removal_here (const AutomataBase< A_ > &a_set, const Weight &, Auto &a, misc::direction_type dir)
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<class A_, typename Auto, typename Weight>
void	do_eps_removal_here_sp (const AutomataBase< A_ > &a_set, const Weight &, Auto &a, misc::direction_type dir)
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 SA, typename A, typename SB, typename B>
bool	do_are_equivalent (const AutomataBase< SA > &, const A &a, const AutomataBase< SB > &, const B &b)
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 S1, typename S2, typename S3, typename M1, typename M2, typename M3, typename M4, typename trans_t, typename auto_t, typename res_t>
void	do_evaluation_fmp (const AutomataBase< S1 > &, const algebra::FreeMonoidProduct< M1, M2 > &, const AutomataBase< S2 > &, const algebra::FreeMonoid< M3 > &, const AutomataBase< S3 > &, const algebra::FreeMonoid< M4 > &, const trans_t &trans, const auto_t &aut, res_t &res)
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 Auto_t>
identity_transducer_helper< S, T >::ret	do_extension (const AutomataBase< S > &s, const Auto_t &a)
template<typename SA, typename ST, typename Auto_t, typename Trans_t>
Trans_t	do_extension (const AutomataBase< SA > &, const TransducerBase< ST > &, const Auto_t &a, const Trans_t &t)
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 S, typename T, typename SS, typename TT, typename Self>
void	do_fmp_to_rw (const vcsn::AutomataBase< S > &, const vcsn::TransducerBase< SS > &, const vcsn::algebra::FreeMonoidProductBase< Self > &, const vcsn::Element< S, T > &fmp, vcsn::Element< SS, TT > &res)
template<typename A, typename AI>
bool	has_succ_comp (const Element< A, AI > &a)
	Return true if the automaton has successful computation.
template<class S, class T>
output_projection_helper< S, T >::ret	image (const Element< S, T > &)
template<typename auto_t, typename trans_t>
static void	do_fmp_image (const trans_t &fmp_trans, auto_t &res)
template<typename Trans_t, typename Auto_t>
static void	do_rw_image (const Trans_t &t, Auto_t &ret)
template<typename S, typename T, typename Auto_t>
static output_projection_helper< S, T >::ret	do_rw_image (const Element< S, T > &t, Auto_t &ret, std::map< typename Auto_t::hstate_t, typename T::hstate_t > &m_)
template<typename S, typename S2, typename T, typename T2, typename ST, typename M1>
static void	image_dispatch (const Element< S, T > &src, const TransducerBase< ST > &, const algebra::FreeMonoidBase< M1 > &, Element< S2, T2 > &dst)
template<typename S, typename S2, typename T, typename T2, typename ST, typename M1>
static void	image_dispatch (const Element< S, T > &src, const TransducerBase< ST > &, const algebra::FreeMonoidBase< M1 > &, Element< S2, T2 > &dst, std::map< typename T::hstate_t, typename T2::hstate_t > &m)
template<typename S, typename T, typename ST>
static output_projection_helper< S, T >::ret	image_dispatch2 (const Element< S, T > &src, const TransducerBase< ST > &, std::map< typename T::hstate_t, typename T::hstate_t > &m)
template<typename S, typename T, typename ST>
static output_projection_helper< S, T >::ret	image_dispatch2 (const Element< S, T > &src, const TransducerBase< ST > &)
template<typename S, typename S2, typename T, typename T2, typename ST, typename M1>
static void	image_dispatch (const Element< S, T > &src, const AutomataBase< ST > &, const algebra::FreeMonoidProductBase< M1 > &, Element< S2, T2 > &dst)
template<typename SA, typename TA, typename ST, typename TT, typename SARET, typename TARET>
void	evaluation (const Element< SA, TA > &a, const Element< ST, TT > &t, Element< SARET, TARET > &ret)
	Evaluate for a "letterized" automaton and a realtime transducer.
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)
	This function computes a set of expression according to the rw_composition algorithm description.
template<typename SA, typename ST, typename SRET, typename Auto_t, typename Trans_t, typename Ret_t>
void	do_evaluation (const AutomataBase< SA > &, const TransducerBase< ST > &, const AutomataBase< SRET > &, const Auto_t &a, const Trans_t &t, Ret_t &ret)
template<typename SA, typename TA, typename ST, typename TT, typename SRET, typename TRET>
void	evaluation (const Element< SA, TA > &a, const Element< ST, TT > &t, Element< SRET, TRET > &ret)
template<typename U, typename V, typename Trans_t, typename M>
void	do_partial_evaluation (const U &E, const TransducerBase< V > &, const Trans_t &S, const typename Trans_t::hstate_t &p, M &res)
template<typename S, typename Auto_t, typename M, typename Chooser_t>
void	do_partial_elimination (const AutomataBase< S > &, const Auto_t &a, Chooser_t chooser, M &state_exp_pair_set)
template<typename A, typename T, typename M>
void	partial_elimination (const Element< A, T > &a, M &state_exp_pair_set)
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 S, typename T>
std::ostream &	operator<< (std::ostream &o, const PartialExp< S, T > &e)
template<typename S, typename T>
std::list< PartialExp< S, T > >	prat_exp_convert (const std::list< Element< S, T > > &exp)
template<typename S, typename T>
bool	operator< (const PartialExp< S, T > &e1, const PartialExp< S, T > &e2)
template<typename S, typename T>
bool	operator== (const PartialExp< S, T > &e1, const PartialExp< S, T > &e2)
template<typename S, typename T>
bool	unweighted_eq (const PartialExp< S, T > &e1, const PartialExp< S, T > &e2)
template<typename S, typename T>
bool	unweighted_inf (const PartialExp< S, T > &e1, const PartialExp< S, T > &e2)
template<typename S, typename T, typename M, typename W>
void	prat_exp_list (PartialExp< S, T > &pexp, const rat::Node< M, W > *node)
template<typename S, typename T, typename M, typename W>
PartialExp< S, T >	prat_exp_convert (const Element< S, T > &exp, const rat::Node< M, W > *node)
template<class Series, class T>
std::pair< typename Element< Series, T >::semiring_elt_t, bool >	constant_term (const PartialExp< Series, T > &exp)
template<class Series, class T, class Letter>
std::pair< std::list< PartialExp< Series, T > >, bool >	prat_exp_derivate (const Element< Series, T > &exp, Letter a)
template<class Series, class T, class Letter>
std::pair< std::list< PartialExp< Series, T > >, bool >	prat_exp_derivate (const PartialExp< Series, T > &exp, Letter a)
template<typename T>
void	list_fusion_here (std::list< T > &dst, std::list< T > &src)
template<typename S, typename T>
void	list_multiply_here_left (std::list< PartialExp< S, T > > &l, const typename PartialExp< S, T >::semiring_elt_t &w)
template<typename S, typename T>
void	list_multiply_here_right (std::list< PartialExp< S, T > > &l, const typename PartialExp< S, T >::semiring_elt_t &w)
template<typename S, typename T>
void	list_insert_here (std::list< PartialExp< S, T > > &l, const typename PartialExp< S, T >::node_t *elm)
template<typename A, typename T>
void	invert (const Element< A, T > &t, Element< A, T > &res)
	Invert a transducer.
template<typename A, typename T>
Element< A, T > &	invert (const Element< A, T > &t)
	Invert a transducer.
template<typename S, typename T>
Element< S, T > &	do_invert_rw (Element< S, T > &t, Element< S, T > &u)
template<typename S, typename T, typename SS, typename TT>
static void	invert_label (const Element< S, T > &label, Element< SS, TT > &res)
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > &	do_invert_tdc (const Element< S, T > &t, Element< SS, TT > &u)
template<typename S, typename T, typename M1, typename M2>
Element< S, T > &	do_invert_fmp (const algebra::FreeMonoidProduct< M1, M2 > &, const Element< S, T > &t)
template<typename S, typename T, typename SS, typename TT, typename M1, typename M2>
Element< SS, TT > &	do_invert_fmp (const algebra::FreeMonoidProduct< M1, M2 > &, const Element< S, T > &t, Element< SS, TT > &res)
template<typename S, typename T>
Element< S, T > &	do_invert (const AutomataBase< S > &, const Element< S, T > &t)
template<typename S, typename T>
Element< S, T > &	do_invert (const AutomataBase< S > &, const Element< S, T > &t, Element< S, T > &res)
template<typename S, typename T>
Element< S, T > &	do_invert (const TransducerBase< S > &, const Element< S, T > &t)
template<typename S, typename T>
Element< S, T > &	do_invert (const TransducerBase< S > &, const Element< S, T > &t, Element< S, T > &res)
template<typename S, typename T>
Element< S, T > &	invert (const Element< S, T > &t)
template<typename S, typename T>
void	invert (const Element< S, T > &t, Element< S, T > &res)
template<typename A, typename AI>
bool	is_ambiguous (const Element< A, AI > &aut)
	Test the ambiguity of automaton.
template<typename A, typename AI>
bool	do_is_ambiguous (const AutomataBase< A > &, const Element< A, AI > &aut)
template<typename A, typename AI>
bool	is_deterministic (const Element< A, AI > &a)
	Test if an automaton is deterministic.
template<typename input_t>
static bool	is_state_deterministic (input_t &input, typename input_t::state_iterator &current_state, typename input_t::series_set_elt_t::semiring_elt_t &zero_semiring)
template<typename A, typename AI>
bool	do_is_deterministic (const AutomataBase< A > &, const Element< A, AI > &input)
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_letterized_transducer (const Element< S, A > &t)
	Test the letter to letter features.
template<typename S, typename A>
bool	do_is_letterized_transducer (const AutomataBase< S > &trans_set, const A &trans)
template<typename S, typename A>
bool	is_normalized_transducer (const Element< S, A > &t)
	Test the normalization of transducer.
template<typename S, typename A>
bool	do_is_normalized_transducer (const AutomataBase< S > &trans_set, const A &trans)
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>
Element< Series, T >	expand (const Element< Series, T > &exp)
template<class S, class E>
E	do_expand (const algebra::SeriesBase< S > &, const E &exp)
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 Exp_, class S_>
bool	do_is_realtime (const algebra::SeriesBase< S_ > &, const Exp_ &exp)
template<class Exp_, class S_>
Exp_	do_realtime (const algebra::SeriesBase< S_ > &, const Exp_ &exp)
template<class Exp_, class S_>
void	do_realtime_here (const algebra::SeriesBase< S_ > &, Exp_ &exp)
template<class S, class T>
Element< S, T >	letter_to_letter_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Undocumented.
template<class Self, class T>
Element< Self, T >	do_letter_to_letter_composition (const TransducerBase< Self > &s, const Element< Self, T > &f, const Element< Self, T > &g)
template<typename S, typename T>
void	do_ltl_to_pair (const Element< S, T > &src, typename MUTE_TRAITS::ret &res)
template<typename S, typename T>
void	ltl_to_pair (const Element< S, T > &ltl, typename MUTE_TRAITS::ret &res)
template<typename A, typename AI>
Element< A, AI >	minimization_hopcroft (const Element< A, AI > &a)
	Minimize a with 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 AI1, typename AI2>
void	do_hopcroft_minimization_det (const AutomataBase< A > &, Element< A, AI2 > &output, const Element< A, AI1 > &input)
template<typename A, typename AI1, typename AI2>
void	do_quotient (const AutomataBase< A > &, const algebra::NumericalSemiring &, SELECTOR(bool), Element< A, AI2 > &output, const Element< A, AI1 > &input)
template<class S, class T, typename A, typename input_t, typename output_t>
void	do_quotient (const AutomataBase< A > &, const S &, const T &, output_t &output, const input_t &input)
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, bool Transposed>
void	do_minimization_moore (const Element< A, AI > &input, Element< A, AI > &output)
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 A, typename AI>
void	do_normalize_here (const AutomataBase< A > &, Element< A, AI > &a)
template<typename A, typename AI1, typename AI2>
void	do_union_of_normalized_here (const AutomataBase< A > &, Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
template<typename A, typename AI>
bool	do_is_normalized (const AutomataBase< A > &, const Element< A, AI > &a)
template<typename A, typename AI1, typename AI2>
void	do_concatenate_of_normalized_here (const AutomataBase< A > &, Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
template<typename A, typename AI>
void	do_star_of_normalized_here (const AutomataBase< A > &, Element< A, AI > &a)
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 S, typename M1, typename M2, typename lhs_t, typename rhs_t, typename res_t>
void	do_compose_dispatcher (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, SELECTOR(bool), const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
template<typename S, typename M1, typename M2, typename lhs_t, typename rhs_t, typename res_t, typename weight_t>
void	do_compose_dispatcher (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const weight_t &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
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 S1, typename S2, typename M1, typename M2, typename auto_t, typename trans_t>
void	do_identity (const AutomataBase< S1 > &, const algebra::FreeMonoidBase< M1 > &, const AutomataBase< S2 > &, const algebra::FreeMonoidProduct< M1, M2 > &, const auto_t &aut, trans_t &res)
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<class Auto>
void	do_realtime_words (Auto &a)
template<class S, class T>
void	realtime_words_here (Element< S, T > &res)
template<class A, typename AI>
bool	do_is_realtime (const AutomataBase< A > &, const Element< A, AI > &a)
template<typename A, typename AI>
void	do_realtime_here (const AutomataBase< A > &, Element< A, AI > &a, misc::direction_type dir=misc::backward)
template<typename A, typename AI>
Element< A, AI >	do_realtime (const AutomataBase< A > &b, const Element< A, AI > &a, misc::direction_type dir=misc::backward)
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 S, typename T>
void	rw_composition (const Element< S, T > &, const Element< S, T > &, Element< S, T > &)
	Composition for Rational-Weight transducers.
template<typename S, typename T>
Element< S, T >	rw_composition (const Element< S, T > &, const Element< S, T > &)
	Composition for Rational-Weight transducers.
template<typename U, typename Trans_t>
void	do_rw_composition (const TransducerBase< U > &, const Trans_t &R, const Trans_t &S, Trans_t &T)
template<typename S, typename T, typename SS, typename TT, typename Self>
void	do_rw_to_fmp (const vcsn::TransducerBase< S > &, const vcsn::AutomataBase< SS > &, const vcsn::algebra::FreeMonoidProductBase< Self > &, const vcsn::Element< S, T > &trans, vcsn::Element< SS, TT > &res)
template<class InputIterator, class FoundFunctor, class Series, class T>
void	search (const Element< Automata< Series >, T > &a, const InputIterator &begin, const InputIterator &end, typename Element< Automata< Series >, T >::letter_t eol, FoundFunctor &f)
	Search for a rational expression into a text.
template<class Series, class T, class StatesSet>
static unsigned int	compute_distances (const Element< Automata< Series >, T > &a, std::vector< StatesSet > &distances)
	Compute distances from initial states to final states.
template<class InputIterator, class Series, class T, class StatesSet>
static std::pair< bool, unsigned int >	window_backsearch (const misc::Window< InputIterator, typename Element< Automata< Series >, T >::letter_t > &w, const Element< Automata< Series >, T > &a, const std::vector< StatesSet > &distances)
	Back search inside a window.
template<class InputIterator, class FoundFunctor, class Series, class T>
static InputIterator	confirm_and_report_match (const misc::Window< InputIterator, typename Element< Automata< Series >, T >::letter_t > &w, const Element< Automata< Series >, T > &a, FoundFunctor &f)
	Finds the longest match of a starting from w, and report it to the functor.
template<typename A, typename AI>
void	standardize (Element< A, AI > &a)
	Returns a standard automaton associated to the input.
template<typename A, typename AI>
bool	is_standard (const Element< A, AI > &a)
	Returns true if the input automaton is standard.
template<typename A, typename AI1, typename AI2>
void	union_of_standard_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
	In-place union of two standard automata.
template<typename A, typename AI1, typename AI2>
Element< A, AI1 >	union_of_standard (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
	Return a fresh union 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 automata.
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<class A, typename AI>
void	do_in_standardize (const AutomataBase< A > &, Element< A, AI > &a)
template<typename A, typename AI1, typename AI2>
void	do_union_of_standard_here (const AutomataBase< A > &, Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
template<typename A, typename AI>
bool	do_is_standard (const AutomataBase< A > &, const Element< A, AI > &a)
template<typename A, typename AI1, typename AI2>
void	do_concat_of_standard_here (const AutomataBase< A > &, Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
template<typename A, typename AI>
void	do_star_of_standard_here (const AutomataBase< A > &, Element< A, AI > &a)
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 Output, typename Exp>
void	do_standard_of (const AutomataBase< A > &, Output &output, const Exp &kexp)
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<typename A, typename AI, typename HStatesSet>
void	do_sub_automaton_here (const AutomataBase< A > &, Element< A, AI > &a, const HStatesSet &selected, bool check_states)
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<class M1, class M2, class Auto>
bool	do_is_sub_normalized (const algebra::FreeMonoidProduct< M1, M2 > &, const Auto &a)
template<class Auto, class Label>
int	do_sub_normalize_transition (Auto &a, typename Auto::hstate_t start, typename Auto::hstate_t stop, const Label &label, bool initial, bool final)
template<class M1, class M2, class Auto, class Ret>
void	do_sub_normalize (const algebra::FreeMonoidProduct< M1, M2 > &, const Auto &a, Ret &res)
template<class S, class T>
void	sub_normalize (const Element< S, T > &a, Element< S, T > &res)
template<typename A, typename AI1, typename AI2>
void	sum_here (Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
	In place summing of two automata.
template<typename A, typename AI1, typename AI2>
Element< A, AI1 >	sum (const Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
	Summing of two automata.
template<typename A, typename AI1, typename AI2>
void	do_sum (const AutomataBase< A > &, Element< A, AI1 > &lhs, const Element< A, AI2 > &rhs)
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 A, typename auto_t, typename Letter, typename Weight>
void	do_thompson_of (const AutomataBase< A > &, auto_t &output, const rat::exp< Letter, Weight > &kexp)
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)
	Remove non useful states from the automaton.
template<typename A, typename AI>
std::set< typename Element< A, AI >::hstate_t >	do_useful_states (const AutomataBase< A > &, const Element< A, AI > &a)
template<class Series>
bool	operator== (const Automata< Series > &, const Automata< Series > &)
template<typename S, typename St, typename T>
St &	op_rout (const AutomataBase< S > &s, St &st, const T &r)
template<typename Auto_>
generalized_traits< Auto_ >::automaton_t	generalized (const Auto_ &from)
template<class S, class T, typename OutputIterator, typename Kind>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::kind< Kind > k)
	Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, int from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::kind< Kind > k)
	Delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, int from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename Kind>
void	op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	Store the output spontaneous transitions.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename Kind>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	Store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename Kind>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename L, typename Kind>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::kind< Kind > k)
	Delta using a query, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, int from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename L, typename Kind>
void	op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::kind< Kind > k)
	Delta on a letter, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, int from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, class Container, typename Kind>
void	op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	Store the output op_spontaneous transitions.
template<class S, class T, class Container, typename Kind>
void	op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename Kind>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	Store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::kind< Kind > k)
	Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, int from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::kind< Kind > k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, int from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, typename OutputIterator, typename Kind>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename Kind>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename Kind>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename L, typename Kind>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::kind< Kind > k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, int from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename L, typename Kind>
void	op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::kind< Kind > k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, int from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, typename Container, typename Kind>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container, typename Kind>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, int from, delta_kind::kind< Kind > k)
template<class S, class T>
automaton_traits< T >::hstate_t	op_choose_state (const AutomataBase< S > &s, const T &v)
template<class S, class T, class Letter>
letter_query< S, T, Letter >	make_letter_query (const S &s, const T &t, const Letter &l)
template<class S, class T>
spontaneous_query< S, T >	make_spontaneous_query (const S &s, const T &t)
template<class S, class T, typename Functor, typename Kind>
void	op_deltaf (const AutomataBase< S > &, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename Kind>
void	op_deltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_deltaf (const AutomataBase< S > &, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_deltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_letter_deltaf (const AutomataBase< S > &s, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_letter_deltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, class Functor, typename Kind>
void	op_spontaneous_deltaf (const AutomataBase< S > &s, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
template<class S, class T, class Functor, typename Kind>
void	op_spontaneous_deltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename Kind>
void	op_rdeltaf (const AutomataBase< S > &, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename Kind>
void	op_rdeltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_rdeltaf (const AutomataBase< S > &, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_rdeltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, const L &query, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_letter_rdeltaf (const AutomataBase< S > &s, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, typename Functor, typename L, typename Kind>
void	op_letter_rdeltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, const L &letter, delta_kind::kind< Kind > k)
template<class S, class T, class Functor, typename Kind>
void	op_spontaneous_rdeltaf (const AutomataBase< S > &s, const T &v, Functor &fun, const typename automaton_traits< T >::hstate_t &from, delta_kind::kind< Kind > k)
template<class S, class T, class Functor, typename Kind>
void	op_spontaneous_rdeltaf (const AutomataBase< S > &s, const T &v, Functor &fun, int from, delta_kind::kind< Kind > k)
template<typename lhs_t, typename rhs_t>
void	auto_copy (lhs_t &dst_, const rhs_t &from)
template<typename auto_t>
auto_t	auto_copy (const auto_t &from)
template<class Series>
bool	operator== (const Transducer< Series > &, const Transducer< Series > &)
template<class S, class T>
Element< S, T >::input_monoid_elt_t	op_input_of (const TransducerBase< S > &s, const T &v, typename automaton_traits< T >::htransition_t e)
template<class S, class T>
Element< S, T >::output_series_set_elt_t	op_output_of (const TransducerBase< S > &s, const T &v, typename automaton_traits< T >::htransition_t e)
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 auto_t, typename F>
auto_t	auto_translate_transitions (const auto_t &from, const F &translate_fun)
template<class S, class T>
const automaton_traits< T >::tag_t &	op_get_tag (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::tag_t &	op_get_tag (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
const automaton_traits< T >::geometry_t &	op_get_geometry (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::geometry_t &	op_get_geometry (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
bool	op_exists (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::states_t	op_states (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::transitions_t	op_transitions (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::initial_support_t	op_initial (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::final_support_t	op_final (const AutomataBase< S > &, const IdentityView< T > &)
template<class S, class T>
void	op_set_initial (const AutomataBase< S > &, IdentityView< T > &, const typename automaton_traits< T >::hstate_t &state, const typename Element< S, IdentityView< T > >::series_set_elt_t &s)
template<class S, class T>
Element< S, IdentityView< T > >::series_set_elt_t	op_get_initial (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::hstate_t &state)
template<class S, class T>
Element< S, T >::series_set_elt_t	op_get_final (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::hstate_t &state)
template<class S, class T>
void	op_clear_initial (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
void	op_clear_final (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::hstate_t	op_add_state (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::hstate_t	op_choose_state (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
automaton_traits< T >::htransition_t	op_add_spontaneous (const AutomataBase< S > &, IdentityView< T > &, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to)
template<class S, class T>
void	op_update (const AutomataBase< S > &, IdentityView< T > &, const typename automaton_traits< T >::htransition_t &, const typename Element< S, IdentityView< T > >::label_t &l)
template<class S, class T>
void	op_del_state (const AutomataBase< S > &, IdentityView< T > &, const typename automaton_traits< T >::hstate_t &)
template<class S, class T>
void	op_del_transition (const AutomataBase< S > &, IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
bool	op_has_state (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::hstate_t &)
template<class S, class T>
bool	op_has_transition (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
automaton_traits< T >::hstate_t	op_src_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
automaton_traits< T >::hstate_t	op_dst_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
Element< S, T >::label_t	op_label_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
const Element< S, T >::series_set_elt_t	op_series_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
Element< S, T >::series_set_elt_value_t	op_series_value_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
Element< S, T >::monoid_elt_t	op_word_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
Element< S, T >::monoid_elt_value_t	op_word_value_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
Element< S, T >::letter_t	op_letter_of (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T>
bool	op_is_spontaneous (const AutomataBase< S > &, const IdentityView< T > &, const typename automaton_traits< T >::htransition_t &)
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output transitions of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output transitions of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::hstate_t &from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<>
bool	operator> (const handler< state_h, boost::shared_ptr< std::size_t > > &h1, const handler< state_h, boost::shared_ptr< std::size_t > > &h2)
template<>
bool	operator<= (const handler< state_h, boost::shared_ptr< std::size_t > > &h1, const handler< state_h, boost::shared_ptr< std::size_t > > &h2)
template<>
bool	operator>= (const handler< state_h, boost::shared_ptr< std::size_t > > &h1, const handler< state_h, boost::shared_ptr< std::size_t > > &h2)
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	Delta with a query and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	Delta on a letter with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	Store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	Store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	Delta with a query and container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	Delta on a letter with container output.
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	Reverse delta without condition, and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	Reverse delta with query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	Reverse delta on a container, with no condition.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &query, delta_kind::transitions k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, const L &letter, delta_kind::transitions k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::hstate_t &from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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 TransposeView< T > &, OutputIterator res, const typename automaton_traits< T >::hstate_t &from, delta_kind::states k)
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::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, const typename automaton_traits< T >::hstate_t &from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<class S, class T>
const automaton_traits< T >::tag_t &	op_get_tag (const AutomataBase< S > &s, const TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::tag_t &	op_get_tag (const AutomataBase< S > &s, TransposeView< T > &v)
template<class S, class T>
const automaton_traits< T >::geometry_t &	op_get_geometry (const AutomataBase< S > &s, const TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::geometry_t &	op_get_geometry (const AutomataBase< S > &s, TransposeView< T > &v)
template<class S, class T>
bool	op_exists (const AutomataBase< S > &s, const TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::states_t	op_states (const AutomataBase< S > &s, const TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::transitions_t	op_transitions (const AutomataBase< S > &s, const TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::hstate_t	op_add_state (const AutomataBase< S > &s, TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::hstate_t	op_choose_state (const AutomataBase< S > &s, TransposeView< T > &v)
template<class S, class T>
automaton_traits< T >::htransition_t	op_add_transition (const AutomataBase< S > &s, TransposeView< T > &v, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::label_t &label)
template<class S, class T>
automaton_traits< T >::htransition_t	op_add_series_transition (const AutomataBase< S > &s, TransposeView< T > &v, 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 &se)
template<class S, class T>
automaton_traits< T >::htransition_t	op_add_spontaneous (const AutomataBase< S > &s, TransposeView< T > &v, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to)
template<class S, class T>
automaton_traits< T >::htransition_t	op_add_letter_transition (const AutomataBase< S > &s, TransposeView< T > &v, const typename automaton_traits< T >::hstate_t &from, const typename automaton_traits< T >::hstate_t &to, const typename Element< S, T >::letter_t &e)
template<class S, class T>
void	op_update (const AutomataBase< S > &s, TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e, const typename Element< S, TransposeView< T > >::label_t &l)
template<class S, class T>
void	op_del_state (const AutomataBase< S > &s, TransposeView< T > &v, const typename automaton_traits< T >::hstate_t &st)
template<class S, class T>
void	op_del_transition (const AutomataBase< S > &s, TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
bool	op_has_state (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::hstate_t &st)
template<class S, class T>
bool	op_has_transition (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
Element< S, T >::label_t	op_label_of (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
const Element< S, T >::series_set_elt_t	op_series_of (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
Element< S, T >::series_set_elt_value_t	op_series_value_of (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
Element< S, T >::monoid_elt_t	op_word_of (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
Element< S, T >::monoid_elt_value_t	op_word_value_of (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
Element< S, T >::letter_t	op_letter_of (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
template<class S, class T>
bool	op_is_spontaneous (const AutomataBase< S > &s, const TransposeView< T > &v, const typename automaton_traits< T >::htransition_t &e)
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 S, typename T>
const S &	op_convert (const Structure< S > &, const Structure< T > &)
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.
template<typename S1, typename T1, typename T2>
static bool	operator== (const Element< S1, T1 > &e1, const T2 &e2)
template<typename T1, typename S2, typename T2>
static bool	operator== (const T1 &e1, const Element< S2, T2 > &e2)
template<typename S1, typename T1, typename T2>
static bool	operator< (const Element< S1, T1 > &e1, const T2 &e2)
template<typename T1, typename S2, typename T2>
static bool	operator< (const T1 &e1, const Element< S2, T2 > &e2)
template<typename S1, typename T1, typename T2>
static bool	operator!= (const Element< S1, T1 > &e1, const T2 &e2)
template<typename T1, typename S2, typename T2>
static bool	operator!= (const T1 &e1, const Element< S2, T2 > &e2)
template<typename S1, typename T1, typename T2>
static bool	operator> (const Element< S1, T1 > &e1, const T2 &e2)
template<typename T1, typename S2, typename T2>
static bool	operator> (const T1 &e1, const Element< S2, T2 > &e2)
template<typename S1, typename T1, typename T2>
static bool	operator>= (const Element< S1, T1 > &e1, const T2 &e2)
template<typename T1, typename S2, typename T2>
static bool	operator>= (const T1 &e1, const Element< S2, T2 > &e2)
template<typename S1, typename T1, typename T2>
static bool	operator<= (const Element< S1, T1 > &e1, const T2 &e2)
template<typename T1, typename S2, typename T2>
static bool	operator<= (const T1 &e1, const Element< S2, T2 > &e2)
template<typename St, typename S, typename T>
static St &	operator>> (St &s, Element< S, T > &e)
template<typename S, typename T>
T::iterator	op_begin (const Structure< S > &s, T &v)
template<typename S, typename T>
T::iterator	op_end (const Structure< S > &s, T &v)
template<typename S, typename T>
T::const_iterator	op_begin_const (const Structure< S > &s, const T &v)
template<typename S, typename T>
T::const_iterator	op_end_const (const Structure< S > &s, const T &v)
template<typename S, typename T>
T::reverse_iterator	op_rbegin (const Structure< S > &s, T &v)
template<typename S, typename T>
T::reverse_iterator	op_rend (const Structure< S > &s, T &v)
template<typename S, typename T>
T::const_reverse_iterator	op_rbegin_const (const Structure< S > &s, const T &v)
template<typename S, typename T>
T::const_reverse_iterator	op_rend_const (const Structure< S > &s, const T &v)
template<typename S, typename T>
bool	op_empty (const Structure< S > &s, const T &v)
template<typename S, typename T>
size_t	op_size (const Structure< S > &s, const T &v)
template<typename S, typename T>
size_t	op_max_size (const Structure< S > &s, const T &v)
template<typename S, typename T, typename U>
bool	op_contains_e (const Structure< S > &s, const T &v, const U &c)
template<typename S, typename T, typename U>
void	op_insert (const Structure< S > &s, T &v, const U &c)
template<typename S, typename T>
bool	op_is_finite (const Structure< S > &s, const T &a)
template<typename Auto, typename TransitionConverter, typename Format>
tools::automaton_saver_< Auto, TransitionConverter, Format >	automaton_saver (const Auto &, const TransitionConverter &e=TransitionConverter(), const Format &f=Format())
template<typename Auto, typename TransitionConverter, typename Format>
tools::automaton_loader_< Auto, TransitionConverter, Format >	automaton_loader (Auto &a, const TransitionConverter &e=TransitionConverter(), const Format &f=Format(), bool merge_states=false)
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)
Letterized FMP automaton to pair letter automaton algorithm.
Compute the pair letter automaton associated to a letterized 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)
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.
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.

Bug:

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

---

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 178 of file words.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::delta(), and BerrySethiAlgo::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::structure().

Referenced by cut_up_here(), and do_sub_normalize().

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 do_cut_up(), SELECT, and Element::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().

Referenced by realtime_words_here().

output_projection_helper<S, T>::ret vcsn::image

(

const Element< S, T > &

)

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 40 of file has_neighbour.hxx.

References precondition.

Referenced by do_is_normalized().

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 50 of file has_neighbour.hxx.

References precondition.

Referenced by do_in_standardize(), do_is_normalized(), and do_is_standard().

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 342 of file normalized_composition.hxx.

References compose().

Referenced by do_compose_dispatcher().

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 364 of file normalized_composition.hxx.

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

Referenced by do_compose_dispatcher().

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.

Referenced by auto_translate_transitions().

Element<S, TransposeView<T> > vcsn::transpose_view

(

Element< S, T > &

)

This function creates a transposed view of an automaton.

See also:

transpose(), TransposeView

Referenced by do_coaccessible_states(), and transpose().

const Element<S, TransposeView<T> > vcsn::transpose_view

(

const Element< S, T > &

)

This function creates a transposed view of an automaton.

See also:

transpose(), TransposeView

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

Delta with a query and iterator output.

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

Definition at line 378 of file transpose_view.hxx.

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

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

Delta on a letter with iterator output.

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

Definition at line 390 of file transpose_view.hxx.

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

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

Delta with a query and container output.

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

Definition at line 426 of file transpose_view.hxx.

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

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

Delta on a letter with container output.

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

Definition at line 438 of file transpose_view.hxx.

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

void op_delta	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		OutputIterator	res,
		const typename automaton_traits< T >::hstate_t &	from,
		delta_kind::states	k
	)

Delta with no condition and iterator output.

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

Definition at line 463 of file transpose_view.hxx.

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

void op_delta	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		OutputIterator	res,
		const typename automaton_traits< T >::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'.

Definition at line 473 of file transpose_view.hxx.

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

void op_letter_delta	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		OutputIterator	res,
		const typename automaton_traits< T >::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.

Definition at line 484 of file transpose_view.hxx.

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

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

Delta without condition, container output.

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

Definition at line 509 of file transpose_view.hxx.

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

void op_deltac	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		Container &	res,
		const typename automaton_traits< T >::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'.

Definition at line 517 of file transpose_view.hxx.

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

void op_letter_deltac	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		Container &	res,
		const typename automaton_traits< T >::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'.

Definition at line 528 of file transpose_view.hxx.

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

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

Reverse delta without condition, and iterator output.

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

Definition at line 553 of file transpose_view.hxx.

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

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

Reverse delta with query, with iterator output.

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

Definition at line 562 of file transpose_view.hxx.

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

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

Reverse delta on a letter, with iterator output.

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

Definition at line 572 of file transpose_view.hxx.

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

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

Reverse delta on a container, with no condition.

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

Definition at line 596 of file transpose_view.hxx.

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

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

Reverse delta using a query, with container output.

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

Definition at line 603 of file transpose_view.hxx.

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

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

Reverse delta on a letter, with container output.

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

Definition at line 613 of file transpose_view.hxx.

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

void op_rdelta	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		OutputIterator	res,
		const typename automaton_traits< T >::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'.

Definition at line 646 of file transpose_view.hxx.

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

void op_letter_rdelta	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		OutputIterator	res,
		const typename automaton_traits< T >::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.

Definition at line 656 of file transpose_view.hxx.

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

void op_rdeltac	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		Container &	res,
		const typename automaton_traits< T >::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'

Definition at line 680 of file transpose_view.hxx.

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

void op_rdeltac	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		Container &	res,
		const typename automaton_traits< T >::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'

Definition at line 687 of file transpose_view.hxx.

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

void op_letter_rdeltac	(	const AutomataBase< S > &	,
		const TransposeView< T > &	,
		Container &	res,
		const typename automaton_traits< T >::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.

Definition at line 697 of file transpose_view.hxx.

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

---