vcsn Namespace Reference
[Miscellaneous constructs used by Vaucanson]

CPP guard should not be inserted here as VCSN_CONTEXT_NAMESPACE could be changed. 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
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	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	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	composition_traits
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	AutomataBase
	It symbolises the set of automata with multiplicity over a fixed semiring and a fixed free monoid. More...
struct	automaton_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	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	output_projection_helper
struct	identity_transducer_helper
struct	TransducerBase
	It denotes the set of transducer with multiplicity over a fixed semiring and a fixed free couple of monoid. More...
struct	transducer_traits
struct	extension_traits
struct	projection_traits
struct	output_projection_traits
struct	virtual_types< TransducerBase< S > >
struct	dynamic_traits< TransducerBase< S > >
struct	MetaElement< TransducerBase< Self >, T >
	MetaElement<TransducerBase<Self>, T> defines the interface of every transducer that is the result of the interaction of a structural element (TransducerBase<Self>) and an implementation T. More...
class	IdentityView
struct	automaton_traits< IdentityView< T > >
struct	generalized_traits
struct	geometry
	Store 4 maps for geometry properties of the automaton. More...
struct	edge_value
	Edge decorator. More...
struct	state_value
	State decorator. More...
class	Graph
	Graph. More...
struct	automaton_traits< Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, Geometry > >
struct	transducer_traits< Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, Geometry > >
struct	projection_traits< S, Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, Geometry > >
struct	output_projection_traits< Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, Geometry > >
struct	extension_traits< Graph< Kind, WordValue, WeightValue, SeriesValue, Letter, Tag, Geometry > >
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
class	GenRandomAutomataSet
class	GenRandomAutomata
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	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	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< S > >
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	MetaElement< algebra::AlphabetSet< L >, algebra::AlphabetDecorator< L, T > >
	Services of every alphabet implemented with AlphabetDecorator<L, T>. More...
struct	MetaElement< algebra::AlphabetSet< L >, std::set< L > >
	Services of every alphabet implemented with std::set. 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 > >
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	geom
namespace	delta_kind
	These are helpers for delta functions: transition or state oriented delta are chosen according to them.
namespace	history
namespace	deltaf_helper
namespace	boolean_automaton
namespace	boolean_transducer
namespace	VCSN_CONTEXT_NAMESPACE
namespace	fmp_transducer
namespace	r_automaton
namespace	tools
namespace	io
namespace	xml
namespace	z_automaton
namespace	z_fmp_transducer
namespace	z_max_plus_automaton
namespace	z_min_plus_automaton
namespace	z_transducer
Determinization algorithms
template<typename A, typename T>
Element< A, T >	determinize (const Element< A, T > &a)
	Returns the determinized of a Boolean automaton.
template<typename A, typename T>
Element< A, T >	determinize (const Element< A, T > &a, std::map< hstate_t, std::set< hstate_t > > &)
	Returns the determinized of a Boolean automaton.
FMP automaton to realtime transducer algorithm.
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > &	fmp_to_realtime (const Element< S, T > &fmp, Element< SS, TT > &res)
	Compute the equivalent transducer of a FMP automaton.
Product algorithm
template<typename A, typename T, typename U>
Element< A, T >	product (const Element< A, T > &lhs, const Element< A, U > &rhs, const bool use_geometry=false)
	Returns a fresh automaton that is the product of the two input ones.
template<typename A, typename T, typename U>
Element< A, T >	product (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< hstate_t, std::pair< hstate_t, hstate_t > > &, const bool use_geometry=false)
	Returns a fresh automaton that is the product of the two input ones.
Realtime transducer to FMP automaton algorithm
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > &	realtime_to_fmp (const Element< S, T > &trans, Element< SS, TT > &res)
	Compute the equivalent FMP automaton of a transducer.
Default operation on automata.
template<class S, class T>
const automaton_traits< T >::tag_t &	op_get_tag (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::tag_t &	op_get_tag (const AutomataBase< S > &, T &)
template<class S, class T>
const automaton_traits< T >::geometry_t &	op_get_geometry (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::geometry_t &	op_get_geometry (const AutomataBase< S > &, T &)
template<class S, class T>
bool	op_exists (const AutomataBase< S > &s, const T &)
template<class S, class T>
automaton_traits< T >::states_t	op_states (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::transitions_t	op_transitions (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::initial_support_t	op_initial (const AutomataBase< S > &, const T &)
template<class S, class T>
automaton_traits< T >::final_support_t	op_final (const AutomataBase< S > &, const T &)
template<class S, class T>
void	op_set_initial (const AutomataBase< S > &, T &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
template<class S, class T>
Element< S, T >::series_set_elt_t	op_get_initial (const AutomataBase< S > &, const T &, hstate_t state)
template<class S, class T>
void	op_set_final (const AutomataBase< S > &, T &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
template<class S, class T>
Element< S, T >::series_set_elt_t	op_get_final (const AutomataBase< S > &, const T &, hstate_t state)
template<class S, class T>
void	op_clear_initial (const AutomataBase< S > &, T &)
template<class S, class T>
void	op_clear_final (const AutomataBase< S > &, T &)
template<class S, class T>
hstate_t	op_add_state (const AutomataBase< S > &, T &)
template<class S, class T>
htransition_t	op_add_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::label_t &label)
template<class S, class T>
htransition_t	op_add_weighted_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::semiring_elt_t &w, const typename Element< S, T >::monoid_elt_value_t &m)
template<class S, class T>
htransition_t	op_add_series_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::series_set_elt_t &)
template<class S, class T>
htransition_t	op_add_spontaneous (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::semiring_elt_t &)
template<class S, class T>
htransition_t	op_add_letter_transition (const AutomataBase< S > &, T &, hstate_t from, hstate_t to, const typename Element< S, T >::letter_t &)
template<class S, class T>
void	op_update (const AutomataBase< S > &, T &, htransition_t, const typename Element< S, T >::label_t &l)
template<class S, class T>
void	op_del_state (const AutomataBase< S > &, T &, hstate_t)
template<class S, class T>
void	op_del_transition (const AutomataBase< S > &, T &, htransition_t)
template<class S, class T>
bool	op_has_state (const AutomataBase< S > &, const T &, hstate_t)
template<class S, class T>
bool	op_has_transition (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
hstate_t	op_src_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
hstate_t	op_dst_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::label_t	op_label_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
const Element< S, T >::series_set_elt_t	op_series_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::series_set_elt_value_t	op_series_value_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::monoid_elt_t	op_word_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::semiring_elt_t	op_weight_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::monoid_elt_value_t	op_word_value_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, T >::letter_t	op_letter_of (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
bool	op_is_spontaneous (const AutomataBase< S > &, const T &, htransition_t)
template<class S, class T>
Element< S, TransposeView< T > >	transpose_view (Element< S, T > &)
	This function creates a transposed view of an automaton.
template<class S, class T>
const Element< S, TransposeView< T > >	transpose_view (const Element< S, T > &)
	This function creates a transposed view of an automaton.
template<class S, class T>
automaton_traits< TransposeView< T > >::initial_support_t	op_initial (const AutomataBase< S > &, const TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
automaton_traits< TransposeView< T > >::final_support_t	op_final (const AutomataBase< S > &, const TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_set_initial (const AutomataBase< S > &, TransposeView< T > &, hstate_t state, const typename Element< S, TransposeView< T > >::series_set_elt_t &s)
	Operations on automata implemented with TransposeView.
template<class S, class T>
Element< S, TransposeView< T > >::series_set_elt_t	op_get_initial (const AutomataBase< S > &, const TransposeView< T > &, hstate_t)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_set_final (const AutomataBase< S > &, TransposeView< T > &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
	Operations on automata implemented with TransposeView.
template<class S, class T>
Element< S, T >::series_set_elt_t	op_get_final (const AutomataBase< S > &, const TransposeView< T > &, hstate_t state)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_clear_initial (const AutomataBase< S > &, TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
void	op_clear_final (const AutomataBase< S > &, TransposeView< T > &)
	Operations on automata implemented with TransposeView.
template<class S, class T>
hstate_t	op_src_of (const AutomataBase< S > &, const TransposeView< T > &, htransition_t)
	Operations on automata implemented with TransposeView.
template<class S, class T>
hstate_t	op_dst_of (const AutomataBase< S > &, const TransposeView< T > &, htransition_t)
	Operations on automata implemented with TransposeView.
Inequality operator for Structures.
Calls equality operator of sub-class.
template<typename S>
bool	operator!= (const vcsn::Structure< S > &a, const vcsn::Structure< S > &b)
Typedefs
typedef handler< state_h >	hstate_t
typedef handler< transition_h >	htransition_t
typedef htransition_t	hedge_t
typedef misc::SparseInterval< hstate_t, std::set< hstate_t > >	StateContainer
	Needed containers.
typedef misc::SparseInterval< hedge_t, std::set< hedge_t > >	EdgeContainer
Enumerations
enum	op_choose_max_word_length_t
	Maximum length of words generated by op_choose. More...
enum	realtime_type
	Enum to indicate which kind of realtime algorithms must be used.
Functions
template<typename S, typename St, typename T>
St &	op_rout (const algebra::AlphabetSetBase< S > &s, St &st, const T &a)
	Implementation of generic stream output operator for alphabets.
template<typename S, typename T, typename L>
bool	op_letter_equality (const algebra::AlphabetSetBase< S > &s, const T &a, L lhs, L rhs)
	Implementation of generic letter equality modulo meta-characters.
template<typename S, typename T>
Element< S, T >	mirror (const Element< S, T > &e)
	Return a fresh word that is the mirror.
template<typename S, typename T, typename CharContainer>
bool	parse_word (Element< S, T > &dest, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped=CharContainer())
	Parse the beginning of the string looking for a word.
template<typename S, typename T, typename CharContainer>
bool	op_parse (const algebra::FreeMonoidBase< S > &s, T &v, const std::string &, typename std::string::const_iterator &, const CharContainer &escaped)
template<typename Self, typename T>
void	op_in_mirror (const algebra::FreeMonoidBase< Self > &s, T &v)
template<typename Self, typename T>
bool	op_contains (const algebra::FreeMonoidBase< Self > &s, const T &v)
template<typename Self, typename St, typename T>
St &	op_rout (const algebra::FreeMonoidBase< Self > &s, St &st, const T &v)
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 T, typename Self>
T	op_default (SELECTOR(algebra::MonoidBase< Self >), SELECTOR(T))
template<typename S, typename T>
op_star_traits< S, T >::ret_t	star (const Element< S, T > &w)
	Returns a fresh weight that is the star of w.
template<typename S, typename T>
bool	parse_weight (Element< S, T > &w, const std::string &, typename std::string::const_iterator &)
	Parse the beginning of the string looking for a weight.
template<typename S, typename T>
bool	starable (const Element< S, T > &elt)
	Returns true if we can compute the star of the weight.
template<typename S, typename T>
bool	op_can_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T))
	Whether a non-starable Element can be chosen from a Semiring.
template<typename S, typename T>
Element< S, T >	op_choose_starable (const algebra::SemiringBase< S > &set, SELECTOR(T))
	A random starable element in the set.
template<typename S, typename T>
Element< S, T >	op_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T))
	A random non-starable element in the set.
template<typename S, typename T>
bool	op_parse (const algebra::SemiringBase< S > &, T &w, const std::string &, typename std::string::const_iterator &)
template<typename Self, typename T>
bool	op_starable (const algebra::SemiringBase< Self > &s, const T &v)
template<typename Self, typename T>
void	op_in_star (const algebra::SemiringBase< Self > &s, T &v)
template<typename Self, typename T>
T	op_default (SELECTOR(algebra::SemiringBase< Self >), SELECTOR(T))
template<typename S, typename T>
Element< S, T >	transpose (const algebra::SeriesBase< S > &s, const T &t)
	returns a fresh series that is the transposed of the argument.
template<typename S, typename T>
bool	is_letter_support (const Element< S, T > &s)
	Returns true if the support of the series is only composed of letters.
template<typename S1, typename S2, typename T1, typename T2>
void	extract_support (Element< S1, T1 > &, Element< S2, T2 > &)
	Make the first series be the support of the second.
template<class S, class T>
Element< S, T >	hadamard (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Return the hadamard product of lhs and rhs.
template<typename S, typename T>
bool	op_is_finite_app (const algebra::SeriesBase< S > &s, const T &t)
template<class S, class T>
Element< S, T >	op_series_choose (const algebra::SeriesBase< S > &s, SELECTOR(T))
template<class S, class T>
algebra::series_traits< T >::support_t	op_support (const algebra::SeriesBase< S > &, const T &v)
template<class S, class M>
S	op_convert (const algebra::SeriesBase< S > &, const algebra::FreeMonoidBase< M > &)
template<class S, class T>
T	op_convert (const algebra::SeriesBase< S > &s, SELECTOR(T), const T &src_)
template<typename S, typename T, typename M, typename W>
void	op_series_structure (const algebra::SeriesBase< S > &s, const T &t, const W &w)
template<class S, class T, class U>
T	op_convert (const algebra::SeriesBase< S > &s, SELECTOR(T), const U &src_)
template<typename L, typename T>
bool	op_contains (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a)
template<typename L, typename T>
bool	op_is_finite (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a)
template<typename L, typename T>
bool	op_contains_e (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a, const L &v)
template<typename T, typename L>
bool	op_letter_equality (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a, L lhs, L rhs)
template<typename L>
size_t	op_max_size (const algebra::AlphabetSet< L > &, const std::set< L > &)
template<typename L>
bool	op_contains (const algebra::AlphabetSet< L > &s, const std::set< L > &a)
template<typename L>
bool	op_is_finite (const algebra::AlphabetSet< L > &s, const std::set< L > &a)
template<typename L>
bool	op_contains_e (const algebra::AlphabetSet< L > &s, const std::set< L > &a, const L &v)
template<typename A>
void	op_in_mul (const algebra::FreeMonoid< A > &s, std::basic_string< typename A::letter_t > &dst, const std::basic_string< typename A::letter_t > &src)
template<typename A>
std::basic_string< typename A::letter_t >	op_mul (const algebra::FreeMonoid< A > &s, const std::basic_string< typename A::letter_t > &a, const std::basic_string< typename A::letter_t > &b)
template<typename A>
std::basic_string< typename A::letter_t >	op_convert (SELECTOR(algebra::FreeMonoid< A >), SELECTOR(std::basic_string< typename A::letter_t >), const typename A::letter_t &c)
template<typename A>
bool	op_xeq (const algebra::FreeMonoid< A > &s, const std::basic_string< typename A::letter_t > &a, const std::basic_string< typename A::letter_t > &b)
template<typename A>
const std::basic_string< typename A::letter_t, misc::char_traits< typename A::letter_t > > &	identity_value (SELECTOR(algebra::FreeMonoid< A >), SELECTOR2(std::basic_string< typename A::letter_t, misc::char_traits< typename A::letter_t > >))
template<class A>
Element< algebra::FreeMonoid< A >, std::basic_string< typename A::letter_t > >	op_choose (const algebra::FreeMonoid< A > &s, SELECTOR(std::basic_string< typename A::letter_t >))
template<typename A>
std::list< typename A::letter_t >	op_convert (SELECTOR(algebra::FreeMonoidBase< A >), SELECTOR(std::list< typename A::letter_t >), const typename A::letter_t &c)
template<typename A>
void	op_in_mul (const algebra::FreeMonoidBase< A > &s, std::list< typename A::letter_t > &dst, const std::list< typename A::letter_t > &src)
template<typename A>
std::list< typename A::letter_t >	op_mul (const algebra::FreeMonoidBase< A > &s, const std::list< typename A::letter_t > &a, const std::list< typename A::letter_t > &b)
template<class Self, typename T>
MetaElement< algebra::FreeMonoidProductBase< Self >, T >::first_monoid_elt_t &	op_first (const algebra::FreeMonoidProductBase< Self > &s, T &v)
template<class Self, typename T>
MetaElement< algebra::FreeMonoidProductBase< Self >, T >::first_monoid_elt_t &	op_second (const algebra::FreeMonoidProductBase< Self > &s, T &v)
template<class F, class S>
void	op_in_mul (const algebra::FreeMonoidProduct< F, S > &s, std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &dst, const std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &src)
template<class F, class S>
std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > >	op_mul (const algebra::FreeMonoidProduct< F, S > &s, const std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &a, const std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &b)
template<class F, class S>
Element< algebra::FreeMonoidProduct< F, S >, std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > >	op_choose (const algebra::FreeMonoidProduct< F, S > &s, SELECTOR2(std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > >))
template<typename Self, typename T>
void	op_in_mirror (const algebra::FreeMonoidProductBase< Self > &s, T &v)
template<typename Self, typename T, typename Ftor>
Ftor::result_type	op_length (const algebra::FreeMonoidProductBase< Self > &, const T &v, Ftor f)
template<typename Self, typename St, typename T>
St &	op_rout (const algebra::FreeMonoidProductBase< Self > &s, St &st, const T &v)
template<typename S, typename U, typename V>
bool	op_parse (const algebra::FreeMonoidBase< S > &set, std::basic_string< std::pair< U, V > > &v, const std::string &s, typename std::string::const_iterator &i, const std::list< char > &escaped)
template<typename S, typename U, typename V>
bool	op_parse (const algebra::FreeMonoidBase< S > &set, std::list< int > &v, const std::string &s, typename std::string::const_iterator &i, const std::list< char > &escaped)
template<typename T>
bool	op_contains (const algebra::NumericalSemiring &s, T c)
template<typename T, typename U>
void	op_in_mul (const algebra::NumericalSemiring &s1, T &dst, U arg)
template<typename T, typename U>
void	op_in_add (const algebra::NumericalSemiring &s1, T &dst, U arg)
template<typename T, typename U>
T	op_mul (const algebra::NumericalSemiring &s, T a, U b)
template<typename T, typename U>
T	op_add (const algebra::NumericalSemiring &s, T a, U b)
template<class T>
Element< algebra::NumericalSemiring, T >	op_choose (const algebra::NumericalSemiring &s, SELECTOR(T))
bool	op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(int))
Element< algebra::NumericalSemiring, int >	op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(int))
Element< algebra::NumericalSemiring, int >	op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(int))
template<typename T>
void	op_in_mul (const algebra::NumericalSemiring &s1, bool &dst, bool src)
bool	op_mul (const algebra::NumericalSemiring &s, bool a, bool b)
void	op_in_add (const algebra::NumericalSemiring &s1, bool &dst, bool src)
bool	op_add (const algebra::NumericalSemiring &s, bool a, bool b)
bool	op_starable (const algebra::NumericalSemiring &s, bool b)
void	op_in_star (const algebra::NumericalSemiring &s, bool &b)
Element< algebra::NumericalSemiring, bool >	op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(bool))
Element< algebra::NumericalSemiring, bool >	op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(bool))
template<typename T>
bool	op_starable (const algebra::NumericalSemiring &s, T v)
bool	op_starable (const algebra::NumericalSemiring &s, const float &f)
bool	op_starable (const algebra::NumericalSemiring &s, const double &f)
void	op_in_star (const algebra::NumericalSemiring &s, float &f)
void	op_in_star (const algebra::NumericalSemiring &s, double &f)
bool	op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(float))
Element< algebra::NumericalSemiring, float >	op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(float))
Element< algebra::NumericalSemiring, float >	op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(float))
bool	op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(double))
Element< algebra::NumericalSemiring, double >	op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(double))
Element< algebra::NumericalSemiring, double >	op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(double))
bool	op_starable (const algebra::NumericalSemiring &s, const algebra::RationalNumber &r)
void	op_in_star (const algebra::NumericalSemiring &s, algebra::RationalNumber &r)
bool	op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(algebra::RationalNumber))
Element< algebra::NumericalSemiring, algebra::RationalNumber >	op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(algebra::RationalNumber))
Element< algebra::NumericalSemiring, algebra::RationalNumber >	op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(algebra::RationalNumber))
template<class TropicalKind, typename T>
bool	op_contains (const algebra::TropicalSemiring< TropicalKind > &s, T c)
template<class TropicalKind, typename T, typename U>
void	op_in_mul (const algebra::TropicalSemiring< TropicalKind > &s1, T &dst, U arg)
template<class TropicalKind, typename T, typename U>
T	op_mul (const algebra::TropicalSemiring< TropicalKind > &s, T a, U b)
template<typename T, typename U>
void	op_in_add (const algebra::TropicalSemiring< algebra::TropicalMax > &s1, T &dst, U arg)
template<typename T, typename U>
void	op_in_add (const algebra::TropicalSemiring< algebra::TropicalMin > &s1, T &dst, U arg)
template<typename T, typename U>
T	op_add (const algebra::TropicalSemiring< algebra::TropicalMax > &s, T a, U b)
template<typename T, typename U>
T	op_add (const algebra::TropicalSemiring< algebra::TropicalMin > &s, T a, U b)
template<typename T>
bool	op_starable (const algebra::TropicalSemiring< algebra::TropicalMin > &, T b)
template<class T>
void	op_in_star (const algebra::TropicalSemiring< algebra::TropicalMin > &s, T &b)
template<typename T>
bool	op_starable (const algebra::TropicalSemiring< algebra::TropicalMax > &, T b)
template<class T>
void	op_in_star (const algebra::TropicalSemiring< algebra::TropicalMax > &, T &b)
template<class TropicalKind, class T>
Element< algebra::TropicalSemiring< TropicalKind >, T >	op_choose (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T))
template<class TropicalKind, typename T>
bool	op_can_choose_non_starable (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T))
template<class TropicalKind, typename T>
Element< algebra::TropicalSemiring< TropicalKind >, T >	op_choose_starable (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T))
template<class TropicalKind, typename T>
Element< algebra::TropicalSemiring< TropicalKind >, T >	op_choose_non_starable (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T))
template<typename St, typename T>
St &	op_rout (const algebra::TropicalSemiring< algebra::TropicalMax > &s, St &st, const T &v)
template<typename St, typename T>
St &	op_rout (const algebra::TropicalSemiring< algebra::TropicalMin > &s, St &st, const T &v)
template<>
float	zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMax >), SELECTOR(float))
template<>
double	zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMax >), SELECTOR(double))
template<>
float	zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMin >), SELECTOR(float))
template<>
double	zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMin >), SELECTOR(double))
template<>
bool	op_starable (const algebra::TropicalSemiring< algebra::TropicalMin > &, bool)
template<>
void	op_in_star (const algebra::TropicalSemiring< algebra::TropicalMin > &, bool &b)
template<typename W, typename M, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_convert (const algebra::Series< W, M > &s1, SELECTOR2(rat::exp< Tm, Tw >), const algebra::Series< W, M > &s2, const algebra::polynom< Tm, Tw > &p_value)
template<typename W, typename M, typename Tm, typename Tw>
bool	op_contains (const algebra::Series< W, M > &, const rat::exp< Tm, Tw > &)
template<typename W, typename M, typename Tm, typename Tw>
bool	op_is_finite_app (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw>
Tm	op_choose_from_supp (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_add (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst, const rat::exp< Tm, Tw > &arg)
template<typename W, typename M, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_mul (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &a, const rat::exp< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_mul (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst, const rat::exp< Tm, Tw > &arg)
template<typename Tm, typename Tw, typename M, typename W>
rat::exp< Tm, Tw >	op_convert (SELECTOR2(algebra::Series< M, W >), SELECTOR2(rat::exp< Tm, Tw >), const Tm &m_value)
template<typename Tm, typename Tw, typename M, typename W>
rat::exp< Tm, Tw >	op_convert (SELECTOR2(algebra::Series< M, W >), SELECTOR2(rat::exp< Tm, Tw >), char m_value)
template<typename Tm, typename Tw, typename W, typename M, typename oTm>
rat::exp< Tm, Tw >	op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >), SELECTOR(M), const oTm &m_value)
template<typename Tm, typename Tw, typename W, typename M, typename oTw>
rat::exp< Tm, Tw >	op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >), SELECTOR(W), const oTw &w_value)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
void	op_assign (const algebra::Series< W, M > &s, const M &monoid, rat::exp< Tm, Tw > &dst, const oTm &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_assign (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &dst, const oTw &src)
template<typename W, typename M, typename Tm, typename Tw>
bool	op_starable (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &dst)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_star (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst)
template<typename W, typename M, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_star (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
void	op_in_add (const algebra::Series< W, M > &s, const M &monoid, rat::exp< Tm, Tw > &dst, const oTm &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
rat::exp< Tm, Tw >	op_add (const algebra::Series< W, M > &s, const M &monoid, const rat::exp< Tm, Tw > &a, const oTm &b)
template<typename M, typename W, typename oTm, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_add (const M &monoid, const algebra::Series< W, M > &s, const oTm &a, const rat::exp< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_in_add (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &dst, const oTw &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
rat::exp< Tm, Tw >	op_add (const algebra::Series< W, M > &s, const W &semiring, const rat::exp< Tm, Tw > &a, const oTw &b)
template<typename W, typename M, typename oTw, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_add (const W &semiring, const algebra::Series< W, M > &s, const oTw &a, const rat::exp< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_in_mul (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &ret, const oTw &w)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
rat::exp< Tm, Tw >	op_mul (const algebra::Series< W, M > &s, const W &semiring, const rat::exp< Tm, Tw > &a, const oTw &w)
template<typename W, typename M, typename oTw, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_mul (const W &semiring, const algebra::Series< W, M > &s, const oTw &w, const rat::exp< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
Tw	op_series_get (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &p, const oTm &m)
template<class W, class M, class Tm, class Tw>
Element< algebra::Series< W, M >, rat::exp< Tm, Tw > >	op_choose (const algebra::Series< W, M > &s, SELECTOR2(rat::exp< Tm, Tw >))
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_transpose (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst)
template<typename W, typename M, typename Tm, typename Tw>
algebra::series_traits< rat::exp< Tm, Tw > >::support_t	op_support (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw>
rat::exp< Tm, Tw >	op_add (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &a, const rat::exp< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw, typename oTm, typename oTw>
void	op_series_set (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &p, const oTm &m, const oTw &w)
template<typename W, typename M, typename Tm, typename Tw>
bool	op_contains (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &m)
template<typename Self, typename Tm, typename Tw>
void	op_in_star (const algebra::SeriesBase< Self > &s, algebra::polynom< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw>
bool	op_is_finite_app (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_add (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &dst, const algebra::polynom< Tm, Tw > &arg)
template<typename W, typename M, typename Tm, typename Tw>
algebra::polynom< Tm, Tw >	op_add (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &a, const algebra::polynom< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw>
algebra::polynom< Tm, Tw >	op_mul (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &a, const algebra::polynom< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_mul (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &dst, const algebra::polynom< Tm, Tw > &arg)
template<typename Tm, typename Tw, typename W, typename M>
algebra::polynom< Tm, Tw >	op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >), const Tm &m_value)
template<typename Tm, typename Tw, typename W, typename M, typename oTw>
algebra::polynom< Tm, Tw >	op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >), SELECTOR(algebra::SemiringBase< W >), const oTw &w_value)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
void	op_assign (const algebra::Series< W, M > &s, const algebra::MonoidBase< M > &monoid, algebra::polynom< Tm, Tw > &dst, const oTm &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_assign (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, algebra::polynom< Tm, Tw > &dst, const oTw &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
void	op_in_add (const algebra::Series< W, M > &s, const algebra::MonoidBase< M > &monoid, algebra::polynom< Tm, Tw > &dst, const oTm &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
algebra::polynom< Tm, Tw >	op_add (const algebra::Series< W, M > &s, const algebra::MonoidBase< M > &monoid, const algebra::polynom< Tm, Tw > &a, const oTm &b)
template<typename M, typename W, typename oTm, typename Tm, typename Tw>
algebra::polynom< Tm, Tw >	op_add (const algebra::MonoidBase< M > &monoid, const algebra::Series< W, M > &s, const oTm &a, const algebra::polynom< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_in_add (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, algebra::polynom< Tm, Tw > &dst, const oTw &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
algebra::polynom< Tm, Tw >	op_add (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, const algebra::polynom< Tm, Tw > &a, const oTw &b)
template<typename W, typename M, typename oTw, typename Tm, typename Tw>
algebra::polynom< Tm, Tw >	op_add (const algebra::SemiringBase< W > &semiring, const algebra::Series< W, M > &s, const oTw &a, const algebra::polynom< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
void	op_in_mul (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, algebra::polynom< Tm, Tw > &dst, const oTw &src)
template<typename W, typename M, typename Tm, typename Tw, typename oTw>
algebra::polynom< Tm, Tw >	op_mul (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, const algebra::polynom< Tm, Tw > &a, const oTw &b)
template<typename W, typename M, typename oTw, typename Tm, typename Tw>
algebra::polynom< Tm, Tw >	op_mul (const algebra::SemiringBase< W > &semiring, const algebra::Series< W, M > &s, const oTw &a, const algebra::polynom< Tm, Tw > &b)
template<typename W, typename M, typename Tm, typename Tw>
void	op_in_transpose (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &t)
template<typename W, typename M, typename St, typename Tm, typename Tw>
St &	op_rout (const algebra::Series< W, M > &s, St &st, const algebra::polynom< Tm, Tw > &p)
template<class W, class M, class Tm, class Tw>
Tm	op_choose_from_supp (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &p)
template<typename W, typename M, typename Tm, typename Tw>
algebra::series_traits< algebra::polynom< Tm, Tw > >::support_t	op_support (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &m)
template<typename W, typename M, typename Tm, typename Tw, typename oTm>
Tw	op_series_get (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &p, const oTm &m)
template<typename W, typename M, typename Tm, typename Tw, typename oTm, typename oTw>
void	op_series_set (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &p, const oTm &m, const oTw &w)
template<class W, class M, class Tm, class Tw>
Element< algebra::Series< W, M >, algebra::polynom< Tm, Tw > >	op_choose (const algebra::Series< W, M > &s, SELECTOR2(algebra::polynom< Tm, Tw >))
template<typename Tm, typename Tw, typename W, typename M, typename oTm>
algebra::polynom< Tm, Tw >	op_convert (const algebra::Series< W, M > &s, SELECTOR2(algebra::polynom< Tm, Tw >), SELECTOR(algebra::MonoidBase< M >), const oTm &m_value)
template<typename A, typename T>
std::set< hstate_t >	accessible_states (const Element< A, T > &a)
	Return accessible states.
template<typename A, typename T>
Element< A, T >	accessible (const Element< A, T > &a)
	Extract the sub-automaton composed of accessible states.
template<typename A, typename T>
void	accessible_here (Element< A, T > &a)
	In-place extract the sub-automaton of accessible states.
template<typename A, typename T>
std::set< hstate_t >	coaccessible_states (const Element< A, T > &a)
	Return co-accessible states.
template<typename A, typename T>
Element< A, T >	coaccessible (const Element< A, T > &a)
	Extract the sub-automaton composed of co-accessible states.
template<typename A, typename T>
void	coaccessible_here (Element< A, T > &a)
	In-place extract the sub-automaton of co-accessible states.
template<class A_, typename Auto_>
std::set< hstate_t >	do_accessible_states (const AutomataBase< A_ > &, const Auto_ &a)
template<class A_, typename Auto_>
std::set< hstate_t >	do_coaccessible_states (const AutomataBase< A_ > &, const Auto_ &a)
template<class Series, class T>
Element< Series, T >	canonical (const Element< Series, T > &exp)
	Transform a krat expression into its canonical form, following aci-rules.
template<class Series_, class Exp_>
Exp_	do_canonical (const algebra::SeriesBase< Series_ > &, const Exp_ &exp)
template<typename A, typename T>
Element< A, T >::series_set_elt_t	aut_to_exp (const Element< A, T > &a)
	Returns a series which describes the language of the automaton.
template<typename A, typename T, typename Chooser_>
Element< A, T >::series_set_elt_t	aut_to_exp (const Element< A, T > &a, const Chooser_ &c)
	Returns a series which describes the language of the automaton.
template<class A_, typename Auto_, typename Chooser_>
Auto_::series_set_elt_t	do_in_aut_to_exp (const AutomataBase< A_ > &a_set, Auto_ &a, Chooser_ chooser)
template<typename A, typename T>
void	backward_realtime_here (Element< A, T > &a)
	In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T >	backward_realtime (const Element< A, T > &a)
	Returns a fresh realtime automaton.
template<class Auto, class Label>
int	do_realtime_words (Auto &a, hstate_t start, hstate_t stop, const Label &label, bool initial, bool final)
template<class S, class T>
void	realtime_words_here (Element< S, T > &res)
template<class A_, typename Auto_>
void	do_backward_realtime_here (const AutomataBase< A_ > &, Auto_ &a)
template<class A_, typename Auto_>
Auto_	do_backward_realtime (const AutomataBase< A_ > &, const Auto_ &a)
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 T>
void	complement_here (Element< A, T > &a)
	Complement in place the set of final states.
template<typename A, typename T>
Element< A, T >	complement (const Element< A, T > &a)
	Complement the set of final states.
template<typename A, typename T>
void	complete_here (Element< A, T > &a)
	Make the transition function of an automaton total w.r.t alphabet.
template<typename A, typename T>
Element< A, T >	complete (const Element< A, T > &a)
	Make the transition function of an automaton total w.r.t alphabet.
template<class A, class T>
bool	is_complete (const Element< A, T > &a)
	Test if the transition function is complete for each state.
template<typename S, typename T>
Element< S, T >	composition_cover (const Element< S, T > &fmp)
	Facade for composition cover.
template<typename S, typename T>
void	composition_cover (const Element< S, T > &fmp, Element< S, T > &ret)
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 T>
void	composition_co_cover (const Element< S, T > &fmp, Element< S, T > &ret)
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<class A, class T>
Element< A, T >	concatenate (const Element< A, T > &lhs, const Element< A, T > &rhs)
	Return the concatenation of two automata.
template<class A, class T>
void	concatenate_here (Element< A, T > &lhs, const Element< A, T > &rhs)
	In place concatenation of two automata.
template<class Self, class Auto>
void	do_auto_in_concat (const AutomataBase< Self > &, Auto &lhs, const Auto &rhs)
template<class S, class T>
bool	is_cut_up (const Element< S, T > &a)
	Check if labels are series with one element.
template<class S, class T>
Element< S, T >	cut_up (const Element< S, T > &a)
	Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<class S, class T>
void	cut_up (const Element< S, T > &a, Element< S, T > &res)
	Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<class S, class T>
void	cut_up_here (Element< S, T > &a)
	Transform an automaton labeled with series to an automaton where all labels are series with one and only one element.
template<class S, class T, class TT, class Auto, class Ret>
void	do_cut_up (const AutomataBase< S > &, const rat::exp< T, TT > &, const Auto &a, Ret &res)
template<class S, class T, class TT, class Auto, class 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 T>
bool	is_deterministic (const Element< A, T > &a)
	Test if an automaton is deterministic.
template<typename A, typename input_t, typename output_t>
void	do_subset_construction (const AutomataBase< A > &, output_t &output, const input_t &input, std::map< hstate_t, std::set< hstate_t > > &m=std::map< hstate_t, std::set< hstate_t > >())
template<typename A, typename T>
Element< A, T >	subset_construction (const Element< A, T > &a)
template<typename A, typename input_t, typename output_t>
void	do_determinize (const AutomataBase< A > &a_set, output_t &output, const input_t &input, std::map< hstate_t, std::set< hstate_t > > &m)
template<typename 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 input_t>
bool	do_is_deterministic (const AutomataBase< A > &, const input_t &input)
template<typename A, typename T>
void	eps_removal_here (Element< A, T > &a, bool bck=true)
	In place eps_removal of an automaton (default is backward eps_removal).
template<typename A, typename T>
Element< A, T >	eps_removal (const Element< A, T > &a, bool bck=true)
	Eps_Removal of an automaton (default is backward eps_removal).
template<typename A, typename T>
void	backward_eps_removal_here (Element< A, T > &a)
	In place backward eps_removal of an automaton.
template<typename A, typename T>
Element< A, T >	backward_eps_removal (const Element< A, T > &a)
	Backward eps_removal of an automaton.
template<typename A, typename T>
void	forward_eps_removal_here (Element< A, T > &a)
	In place forward eps_removal of an automaton.
template<typename A, typename T>
Element< A, T >	forward_eps_removal (const Element< A, T > &a)
	Forward eps_removal of an automaton.
template<class A_, typename Auto>
void	do_eps_removal_here (const AutomataBase< A_ > &, Auto &a, bool bck_fwd)
template<typename A, typename T, typename W>
Element< A, T >::semiring_elt_t	eval (const Element< A, T > &a, const W &word)
	Return the image of a word by an automaton.
template<typename SA, typename TA, typename ST, typename TT, typename SARET, typename TARET>
void	evaluation (const Element< SA, TA > &, const Element< ST, TT > &, Element< SARET, TARET > &)
	Evaluate for a "letterized" automaton and a realtime transducer.
template<typename SA, typename TA, typename ST, typename TT, typename M>
void	partial_1 (const Element< SA, TA > &, const Element< ST, TT > &, M &)
template<typename SA, typename TA, typename ST, typename TT, typename Exp>
void	partial_2 (const Element< SA, TA > &, const Element< ST, TT > &, const hstate_t, Exp &)
template<typename SA, typename TA, typename ST, typename TT, typename M>
void	partial_3 (const Element< SA, TA > &, const Element< ST, TT > &, const hstate_t, M &)
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 E, typename S, typename Trans_t, typename M>
void	do_partial_evaluation (const E &exp, const TransducerBase< S > &, const Trans_t &t, M &state_exp_pair_set)
template<typename S1, typename T1, typename S2, typename T2, typename M>
void	partial_evaluation (const Element< S1, T1 > &exp, const Element< S2, T2 > &trans, M &state_exp_pair_set)
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 SA, typename ST, typename Auto_t, typename Trans_t, typename M>
void	do_partial_1 (const AutomataBase< SA > &, const TransducerBase< ST > &, const Auto_t &a, const Trans_t &t, M &state_exp_pair_set)
template<typename SA, typename ST, typename Auto_t, typename Trans_t, typename Exp>
void	do_partial_2 (const AutomataBase< SA > &, const TransducerBase< ST > &, const Auto_t &a, const Trans_t &t, const hstate_t p, Exp &exp)
template<typename SA, typename ST, typename Auto_t, typename Trans_t, typename M>
void	do_partial_3 (const AutomataBase< SA > &, const TransducerBase< ST > &, const Auto_t &a, const Trans_t &t, const hstate_t p, M &state_exp_pair_set)
template<typename SA, typename TA, typename ST, typename TT, typename SARET, typename TARET>
void	evaluation_fmp (const Element< ST, TT > &, const Element< SA, TA > &, Element< SARET, TARET > &)
	Evaluation over normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename 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 SA, typename TA, typename ST, typename TT, typename SARES, typename TARES>
void	evaluation_fmp (const Element< ST, TT > &trans, const Element< SA, TA > &aut, Element< SARES, TARES > &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_realtime (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 T>
void	forward_realtime_here (Element< A, T > &a)
	In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T >	forward_realtime (const Element< A, T > &a)
	Returns a fresh realtime automaton.
template<class A_, typename Auto_>
void	do_forward_realtime_here (const AutomataBase< A_ > &, Auto_ &a)
template<typename A_, typename Auto_>
Auto_	do_forward_realtime (const AutomataBase< A_ > &, const Auto_ &a)
template<typename A, typename T>
bool	has_successors (const Element< A, T > &a, const hstate_t s)
	Whether a state has successors.
template<typename A, typename T>
bool	has_predecessors (const Element< A, T > &a, const hstate_t s)
	Whether a state has predecessors.
template<typename 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>
PartialExp< S, T >	prat_exp_convert (const 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 > &)
	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>
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 S, typename A>
bool	is_ambiguous (const Element< S, A > &aut)
	Test the ambiguity of automaton.
template<typename A_, typename Auto_>
bool	do_is_ambiguous (const AutomataBase< A_ > &, const Auto_ &aut)
template<typename A_, typename Auto_>
bool	is_ambiguous (const Element< A_, Auto_ > &aut)
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 S, typename A>
bool	do_is_realtime (const TransducerBase< S > &, 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>
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 A, typename T>
Element< A, T >	minimization_hopcroft (const Element< A, T > &a)
	Return the minimal automaton using the hopcroft algorithm.
template<typename A, typename T>
Element< A, T >	quotient (const Element< A, T > &a)
	Return the quotient of a non-deterministic acceptor.
template<typename A, typename input_t, typename output_t>
void	do_hopcroft_minimization_det (const AutomataBase< A > &, output_t &output, const input_t &input)
template<typename A, typename input_t, typename output_t>
void	do_quotient (const AutomataBase< A > &, const algebra::NumericalSemiring &, SELECTOR(bool), output_t &output, const input_t &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 T>
Element< A, T >	minimization_moore (const Element< A, T > &a)
	Returns the minimal deterministic automaton associated to the input one.
template<typename A, typename T>
Element< A, T >	co_minimization_moore (const Element< A, T > &a)
	Returns the co-minimal co-deterministic automaton associated to the input one.
template<typename A, typename T>
void	minimization_moore_here (Element< A, T > &a)
	Minimalize the deterministic input automaton.
template<typename A, typename T>
void	co_minimization_moore_here (Element< A, T > &a)
	Co-minimalize the co-deterministic input automaton.
template<typename A, typename T, bool Transposed>
void	do_minimization_moore (const Element< A, T > &input, Element< A, T > &output)
template<typename A, typename T>
Element< A, T >	normalize (const Element< A, T > &a)
	Return the fresh thompson-normalized automaton.
template<typename A, typename T>
void	normalize_here (Element< A, T > &a)
	In-place normalize to the thompson form.
template<typename A, typename T>
bool	is_normalized (const Element< A, T > &a)
	Return true if the input automaton is thompson-normalized.
template<typename A, typename T, typename U>
void	union_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	Do the in-place union of two thompson-normalized automata.
template<typename A, typename T, typename U>
Element< A, T >	union_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return the fresh union of two thompson-normalized automata.
template<typename A, typename T, typename U>
void	concatenate_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	Do the in-place concatenation of two thompson-normalized automata.
template<typename A, typename T, typename U>
Element< A, T >	concatenate_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return the fresh concatenation of two thompson-normalized automata.
template<typename A, typename T>
void	star_of_normalized_here (Element< A, T > &a)
	Do in-place star transformation on the thompson-normalized input.
template<typename A, typename T>
Element< A, T >	star_of_normalized (const Element< A, T > &a)
	Return the fresh star transformation of its normalized input.
template<class A_, typename Auto_>
void	do_normalize_here (const AutomataBase< A_ > &, Auto_ &a)
template<typename A, typename lhs_t, typename rhs_t>
void	do_union_of_normalized_here (const AutomataBase< A > &, lhs_t &lhs, const rhs_t &rhs)
template<typename A, typename auto_t>
bool	do_is_normalized (const AutomataBase< A > &, const auto_t &a)
template<typename A, typename lhs_t, typename rhs_t>
void	do_concatenate_of_normalized_here (const AutomataBase< A > &, lhs_t &lhs, const rhs_t &rhs)
template<typename A, typename auto_t>
void	do_star_of_normalized_here (const AutomataBase< A > &, auto_t &a)
template<typename S, typename T>
void	compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
	Facade for compose.
template<typename S, typename T>
Element< S, T >	compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Composition for unweighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
void	u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
	Facade for unambiguous composition.
template<typename S, typename T>
Element< S, T >	u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
	Unambiguous composition for unweighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename res_t>
void	add_transition (res_t &output, composition_traits::visited_t &visited, composition_traits::to_process_t &to_process, std::set< hstate_t > &lhs_states, std::set< hstate_t > &rhs_states, composition_traits::map_of_states_t &m, const hstate_t current_state, const hstate_t from, const hstate_t to, typename res_t::series_set_elt_t &prod_series)
template<typename S, typename M1, typename M2, typename lhs_t, typename rhs_t, typename res_t>
void	do_b_composition (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const lhs_t &lhs, const rhs_t &rhs, res_t &output, std::set< hstate_t > &lhs_states, std::set< hstate_t > &rhs_states, composition_traits::map_of_states_t &m)
template<typename S, typename M1, typename M2, typename coeff_t, typename lhs_t, typename rhs_t, typename res_t>
void	do_compose (const AutomataBase< S > &, const algebra::FreeMonoidProduct< M1, M2 > &, const coeff_t &, const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
	compose with multiplicities
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 > &, SELECTOR(bool), const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
	compose with boolean multiplicities
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 > &, SELECTOR(bool), const lhs_t &lhs, const rhs_t &rhs, res_t &ret)
	unambiguous compose with boolean multiplicities
template<typename A, typename lhs_t, typename rhs_t, typename output_t>
void	product (const AutomataBase< A > &, output_t &output, const lhs_t &lhs, const rhs_t &rhs, std::map< hstate_t, std::pair< hstate_t, hstate_t > > &m, const bool use_geometry=false)
template<class ST, class TT, class SA, class TA>
void	output_projection (const Element< ST, TT > &, Element< SA, TA > &)
template<class S, class T>
output_projection_helper< S, T >::ret	output_projection (const Element< S, T > &, std::map< hstate_t, hstate_t > &m)
template<class S, class T>
output_projection_helper< S, T >::ret	output_projection (const Element< S, T > &)
template<class S, class T>
input_projection_helper< S, T >::ret	input_projection (const Element< S, T > &)
template<typename ST, typename SA, typename Trans_t, typename Auto_t>
void	do_output_projection (const TransducerBase< ST > &, const AutomataBase< SA > &, const Trans_t &t, Auto_t &ret)
template<typename S, typename T>
output_projection_helper< S, T >::ret	do_output_projection (const TransducerBase< S > &, const Element< S, T > &t, std::map< hstate_t, hstate_t > &m_)
template<typename S, typename T>
input_projection_helper< S, T >::ret	do_input_projection (const TransducerBase< S > &, const Element< S, T > &t)
template<typename S, typename S2, typename T, typename T2>
void	domain (const Element< S, T > &aut, Element< S2, T2 > &res)
template<typename S, typename S2, typename T, typename T2>
Element< S2, T2 >	domain (const Element< S, T > &aut)
template<typename S, typename S2, typename T, typename T2>
void	image (const Element< S, T > &aut, Element< S2, T2 > &res)
template<typename S, typename S2, typename T, typename T2>
Element< S2, T2 >	image (const Element< S, T > &aut)
template<typename S, typename S2, typename T, typename T2>
void	identity (const Element< S, T > &aut, Element< S2, T2 > &res)
template<typename S, typename S2, typename T, typename T2>
Element< S2, T2 >	identity (const Element< S, T > &aut)
template<typename auto_t, typename trans_t>
static void	set_states (const trans_t &fmp_trans, auto_t &res, std::map< hstate_t, hstate_t > &stmap)
template<typename S1, typename S2, typename M1, typename M2, typename M3, typename auto_t, typename trans_t>
void	do_domain (const AutomataBase< S1 > &, const algebra::FreeMonoidProduct< M1, M2 > &, const AutomataBase< S2 > &, const algebra::FreeMonoid< M3 > &, const trans_t &fmp_trans, auto_t &res)
template<typename S1, typename S2, typename M1, typename M2, typename auto_t, typename trans_t>
void	do_image (const AutomataBase< S1 > &, const algebra::FreeMonoidProduct< M1, M2 > &, const AutomataBase< S2 > &, const algebra::FreeMonoidBase< M2 > &, const trans_t &fmp_trans, auto_t &res)
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 T>
void	realtime_here (Element< A, T > &a, realtime_type type)
	In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T >	realtime (const Element< A, T > &a, realtime_type type)
	Returns a fresh realtime automaton.
template<class A_, typename Auto_>
bool	do_is_realtime (const AutomataBase< A_ > &, const Auto_ &a)
template<typename Auto_, typename A_>
void	do_realtime_here (const AutomataBase< A_ > &, Auto_ &a, realtime_type type=forward)
template<typename Auto_, typename A_>
Auto_	do_realtime (const AutomataBase< A_ > &, const Auto_ &a, realtime_type type=forward)
template<typename S, typename T>
void	realtime_composition (const Element< S, T > &, const Element< S, T > &, Element< S, T > &)
	Composition for realtime transducers.
template<typename S, typename T>
Element< S, T >	realtime_composition (const Element< S, T > &, const Element< S, T > &)
	Composition for realtime transducers.
template<typename S, typename Trans_t>
void	do_realtime_composition (const TransducerBase< S > &, const Trans_t &lhs, const Trans_t &rhs, Trans_t &ret)
template<typename S, typename T>
Element< S, T >	realtime (const Element< S, T > &e)
	Calls the do_realtime function for rational expression or automata.
template<typename S, typename T>
void	realtime_here (Element< S, T > &e)
	Calls the do_realtime_here function for rational expression or automata.
template<typename S, typename T>
bool	is_realtime (const Element< S, T > &e)
	Test whether an automaton or a regular expression is realtime.
template<typename S, typename T, typename SS, typename TT, typename Self>
void	do_realtime_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 T>
void	standardize (Element< A, T > &a)
	Returns a standard automaton associated to the input.
template<typename A, typename T>
bool	is_standard (const Element< A, T > &a)
	Returns true if the input automaton is standard.
template<typename A, typename T, typename U>
void	union_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In-place union of two standard automata.
template<typename A, typename T, typename U>
Element< A, T >	union_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return a fresh union of two standard automata.
template<typename A, typename T, typename U>
void	concat_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In-place concatenation of two standard automata.
template<typename A, typename T, typename U>
Element< A, T >	concat_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return a fresh concatenation of two standard automata.
template<typename A, typename T>
void	star_of_standard_here (Element< A, T > &a)
	In-place star transformation of a standard automata.
template<typename A, typename T>
Element< A, T >	star_of_standard (const Element< A, T > &a)
	Return the fresh star transformation of a standard automata.
template<class A_, typename Auto_>
void	do_in_standardize (const AutomataBase< A_ > &, Auto_ &a)
template<typename A, typename lhs_t, typename rhs_t>
void	do_union_of_standard_here (const AutomataBase< A > &, lhs_t &lhs, const rhs_t &rhs)
template<typename A, typename auto_t>
bool	do_is_standard (const AutomataBase< A > &, const auto_t &a)
template<typename A, typename lhs_t, typename rhs_t>
void	do_concat_of_standard_here (const AutomataBase< A > &, lhs_t &lhs, const rhs_t &rhs)
template<typename A, typename auto_t>
void	do_star_of_standard_here (const AutomataBase< A > &, auto_t &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 T, typename Exp>
Element< A, T >	standard_of (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 T, typename StatesSet>
Element< A, T >	sub_automaton (const Element< A, T > &a, const StatesSet &s, bool check_states=true)
	Returns a fresh automaton that is the sub-automaton defined by a set.
template<typename A, typename T, typename StatesSet>
void	sub_automaton_here (Element< A, T > &a, const StatesSet &s, bool check_states=true)
	Select a sub-automaton into a given automaton.
template<typename A, typename auto_t, typename list_t>
void	do_sub_automaton_here (const AutomataBase< A > &, auto_t &a, const list_t &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, hstate_t start, 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 T, typename U>
void	sum_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In place summing of two automata.
template<typename A, typename T, typename U>
Element< A, T >	sum (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Summing of two automata.
template<typename A, typename lhs_t, typename rhs_t>
void	do_sum (const AutomataBase< A > &, lhs_t &lhs, const rhs_t &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 lhs_t, typename rhs_t>
void	transpose (lhs_t &dst, const rhs_t &from)
	Transposition of an automaton.
template<typename auto_t>
auto_t	transpose (const auto_t &from)
	Return a fresh transposed automaton.
template<typename A, typename T>
std::set< hstate_t >	useful_states (const Element< A, T > &a)
	Returns a useful states of the automaton (start reachable and final co-).
template<typename A, typename T>
Element< A, T >	trim (const Element< A, T > &a)
	Return a fresh automaton in which non useful states are removed.
template<typename A, typename T>
void	trim_here (Element< A, T > &a)
	Trim a.
template<class A_, typename Auto_>
std::set< hstate_t >	do_useful_states (const AutomataBase< A_ > &, const Auto_ &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<class S, class T, typename OutputIterator, typename Kind>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
	Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_letter_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
	Delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_spontaneous_delta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
	Store the output spontaneous transitions.
template<class S, class T, typename Container, typename Kind>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
	Store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
	Delta using a query, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_letter_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
	Delta on a letter, with container output.
template<class S, class T, class Container, typename Kind>
void	op_spontaneous_deltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
	Store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
	Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L, typename Kind>
void	op_letter_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator, typename Kind>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const T &, OutputIterator res, hstate_t from, delta_kind::kind< Kind > k)
	Store the output op_spontaneous transitions.
template<class S, class T, typename Container, typename Kind>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
	store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &query, delta_kind::kind< Kind > k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L, typename Kind>
void	op_letter_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, const L &letter, delta_kind::kind< Kind > k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container, typename Kind>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const T &, Container &res, hstate_t from, delta_kind::kind< Kind > k)
	store the output op_spontaneous transitions.
template<class S, class 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, hstate_t 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, hstate_t 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, hstate_t 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, hstate_t 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, hstate_t 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, hstate_t 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, hstate_t 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, hstate_t 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<typename kind>
bool	operator== (const handler< kind > &h1, const handler< kind > &h2)
template<typename kind>
bool	operator!= (const handler< kind > &h1, const handler< kind > &h2)
template<typename kind>
bool	operator< (const handler< kind > &h1, const handler< kind > &h2)
template<typename kind>
bool	operator> (const handler< kind > &h1, const handler< kind > &h2)
template<typename kind>
bool	operator<= (const handler< kind > &h1, const handler< kind > &h2)
template<typename kind>
bool	operator>= (const handler< kind > &h1, const handler< kind > &h2)
template<class S, class T>
identity_transducer_helper< S, T >::ret	partial_identity (const Element< S, T > &)
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, 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, htransition_t e)
template<class S, class T>
htransition_t	op_add_io_transition (const TransducerBase< S > &s, T &v, hstate_t from, hstate_t to, typename Element< S, T >::input_letter_t i, typename Element< S, T >::output_letter_t o, typename Element< S, T >::output_semiring_elt_t w)
template<class S, class T>
htransition_t	op_add_io_transition (const TransducerBase< S > &s, T &v, hstate_t from, hstate_t to, typename Element< S, T >::input_monoid_elt_t input_w, typename Element< S, T >::output_monoid_elt_t output_w, typename Element< S, T >::output_semiring_elt_t w)
template<class S, class T>
htransition_t	op_add_i_transition (const TransducerBase< S > &s, T &v, hstate_t from, hstate_t to, typename Element< S, T >::input_letter_t i, typename Element< S, T >::output_semiring_elt_t w)
template<class S, class T>
htransition_t	op_add_o_transition (const TransducerBase< S > &s, T &v, hstate_t from, hstate_t to, typename Element< S, T >::input_letter_t o, typename Element< S, T >::output_semiring_elt_t w)
template<class S, class T>
static Element< S, T >::series_set_elt_t	make_series (const TransducerBase< S > &s, typename Element< S, T >::output_monoid_elt_value_t o)
template<class S, class T>
void	op_set_o_final (const TransducerBase< S > &s, T &v, hstate_t final, typename Element< S, T >::output_monoid_elt_value_t o)
template<class S, class T>
void	op_set_o_initial (const TransducerBase< S > &s, T &v, hstate_t initial, typename Element< S, T >::output_monoid_elt_value_t o)
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 > &, 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 > &, hstate_t state)
template<class S, class T>
void	op_set_final (const AutomataBase< S > &, IdentityView< T > &, hstate_t state, const typename Element< S, T >::series_set_elt_t &s)
template<class S, class T>
Element< S, T >::series_set_elt_t	op_get_final (const AutomataBase< S > &, const IdentityView< 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>
hstate_t	op_add_state (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
hstate_t	op_choose_state (const AutomataBase< S > &, IdentityView< T > &)
template<class S, class T>
htransition_t	op_add_transition (const AutomataBase< S > &, IdentityView< T > &, hstate_t from, hstate_t to, const typename Element< S, T >::label_t &label)
template<class S, class T>
htransition_t	op_add_series_transition (const AutomataBase< S > &, IdentityView< T > &, hstate_t from, hstate_t to, const typename Element< S, T >::series_set_elt_t &)
template<class S, class T>
htransition_t	op_add_spontaneous (const AutomataBase< S > &, IdentityView< T > &, hstate_t from, hstate_t to)
template<class S, class T>
htransition_t	op_add_letter_transition (const AutomataBase< S > &, IdentityView< T > &, hstate_t from, hstate_t to, const typename Element< S, T >::letter_t &)
template<class S, class T>
void	op_update (const AutomataBase< S > &, IdentityView< 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 > &, hstate_t)
template<class S, class T>
void	op_del_transition (const AutomataBase< S > &, IdentityView< T > &, htransition_t)
template<class S, class T>
bool	op_has_state (const AutomataBase< S > &, const IdentityView< T > &, hstate_t)
template<class S, class T>
bool	op_has_transition (const AutomataBase< S > &, const IdentityView< T > &, htransition_t)
template<class S, class T>
hstate_t	op_src_of (const AutomataBase< S > &, const IdentityView< T > &, htransition_t)
template<class S, class T>
hstate_t	op_dst_of (const AutomataBase< S > &, const IdentityView< T > &, htransition_t)
template<class S, class T>
Element< S, T >::label_t	op_label_of (const AutomataBase< S > &, const IdentityView< 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 > &, 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 > &, htransition_t)
template<class S, class T>
Element< S, T >::monoid_elt_t	op_word_of (const AutomataBase< S > &, const IdentityView< 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 > &, htransition_t)
template<class S, class T>
Element< S, T >::letter_t	op_letter_of (const AutomataBase< S > &, const IdentityView< T > &, htransition_t)
template<class S, class T>
bool	op_is_spontaneous (const AutomataBase< S > &, const IdentityView< T > &, htransition_t)
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	store the output transitions of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	store the output transitions of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::transitions k)
	store the output transitions of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where the label matches the letter.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const IdentityView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	store the output states of the state 'from' where query(label(e)) = true in the container 'res'
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const IdentityView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class Auto_>
generalized_traits< Auto_ >::automaton_t	generalized (const Auto_ &from)
template<class Kind, class WordValue, class WeightValue, class SerieValue, class Letter, class Tag, class Geometry, class I>
Tag &	op_tag (const AutomataBase< I > &, Graph< Kind, WordValue, WeightValue, SerieValue, Letter, Tag, Geometry > &)
template<class Kind, class WordValue, class WeightValue, class SerieValue, class Letter, class Tag, class Geometry, class I>
const Tag &	op_tag (const AutomataBase< I > &, const Graph< Kind, WordValue, WeightValue, SerieValue, Letter, Tag, Geometry > &)
template<class Kind, class WordValue, class WeightValue, class SerieValue, class Letter, class Tag, class Geometry, class I>
Geometry &	op_geometry (const AutomataBase< I > &, Graph< Kind, WordValue, WeightValue, SerieValue, Letter, Tag, Geometry > &)
template<class Kind, class WordValue, class WeightValue, class SerieValue, class Letter, class Tag, class Geometry, class I>
const Geometry &	op_geometry (const AutomataBase< I > &, const Graph< Kind, WordValue, WeightValue, SerieValue, Letter, Tag, Geometry > &)
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	store the output transitions of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::transitions k)
	Delta with a query and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::transitions k)
	Delta on a letter with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	Store the output spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	Store the output transitions of the state 'from' in the container 'res'.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::transitions k)
	Delta with a query and container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::transitions k)
	Delta on a letter with container output.
template<class S, class T, class Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	Delta with no condition and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	Delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	Delta on a letter with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_delta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	Delta without condition, container output.
template<class S, class T, typename Container, typename L>
void	op_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	Delta with a query, using container output.
template<class S, class T, typename Container, typename L>
void	op_letter_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	Delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_deltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	Reverse delta without condition, and iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::transitions k)
	Reverse delta with query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::transitions k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename Container>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	Reverse delta on a container, with no condition.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::transitions k)
	Reverse delta using a query, with container output.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::transitions k)
	Reverse delta on a letter, with container output.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::transitions k)
	store the output op_spontaneous transitions.
template<class S, class T, typename OutputIterator>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, delta_kind::states k)
	store the output states of the state 'from' using 'res'.
template<class S, class T, typename OutputIterator, typename L>
void	op_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &query, delta_kind::states k)
	Reverse delta using a query, with iterator output.
template<class S, class T, typename OutputIterator, typename L>
void	op_letter_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, hstate_t from, const L &letter, delta_kind::states k)
	Reverse delta on a letter, with iterator output.
template<class S, class T, typename OutputIterator>
void	op_spontaneous_rdelta (const AutomataBase< S > &, const TransposeView< T > &, OutputIterator res, 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, hstate_t from, delta_kind::states k)
	Reverse delta on a container, with no conditions.
template<class S, class T, typename Container, typename L>
void	op_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &query, delta_kind::states k)
	Reverse delta in a container, with a query.
template<class S, class T, typename Container, typename L>
void	op_letter_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, const L &letter, delta_kind::states k)
	Reverse delta in a container, on a letter.
template<class S, class T, typename Container>
void	op_spontaneous_rdeltac (const AutomataBase< S > &, const TransposeView< T > &, Container &res, hstate_t from, delta_kind::states k)
	Store the output op_spontaneous transitions.
template<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>
hstate_t	op_add_state (const AutomataBase< S > &s, TransposeView< T > &v)
template<class S, class T>
hstate_t	op_choose_state (const AutomataBase< S > &s, TransposeView< T > &v)
template<class S, class T>
htransition_t	op_add_transition (const AutomataBase< S > &s, TransposeView< T > &v, hstate_t from, hstate_t to, const typename Element< S, T >::label_t &label)
template<class S, class T>
htransition_t	op_add_series_transition (const AutomataBase< S > &s, TransposeView< T > &v, hstate_t from, hstate_t to, const typename Element< S, T >::series_set_elt_t &se)
template<class S, class T>
htransition_t	op_add_spontaneous (const AutomataBase< S > &s, TransposeView< T > &v, hstate_t from, hstate_t to)
template<class S, class T>
htransition_t	op_add_letter_transition (const AutomataBase< S > &s, TransposeView< T > &v, hstate_t from, 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, 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, hstate_t st)
template<class S, class T>
void	op_del_transition (const AutomataBase< S > &s, TransposeView< T > &v, htransition_t e)
template<class S, class T>
bool	op_has_state (const AutomataBase< S > &s, const TransposeView< T > &v, hstate_t st)
template<class S, class T>
bool	op_has_transition (const AutomataBase< S > &s, const TransposeView< T > &v, htransition_t e)
template<class S, class T>
Element< S, T >::label_t	op_label_of (const AutomataBase< S > &s, const TransposeView< T > &v, 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, 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, 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, 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, htransition_t e)
template<class S, class T>
Element< S, T >::letter_t	op_letter_of (const AutomataBase< S > &s, const TransposeView< T > &v, htransition_t e)
template<class S, class T>
bool	op_is_spontaneous (const AutomataBase< S > &s, const TransposeView< T > &v, 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>
bool	operator== (const Element< S1, T1 > &x1, const T2 &x2)
template<typename T1, typename S2, typename T2>
bool	operator== (const T1 &x1, const Element< S2, T2 > &x2)
template<typename S1, typename T1, typename T2>
bool	operator< (const Element< S1, T1 > &x1, const T2 &x2)
template<typename T1, typename S2, typename T2>
bool	operator< (const T1 &x1, const Element< S2, T2 > &x2)
template<typename S1, typename T1, typename T2>
bool	operator!= (const Element< S1, T1 > &x1, const T2 &x2)
template<typename T1, typename S2, typename T2>
bool	operator!= (const T1 &x1, const Element< S2, T2 > &x2)
template<typename S1, typename T1, typename T2>
bool	operator> (const Element< S1, T1 > &x1, const T2 &x2)
template<typename T1, typename S2, typename T2>
bool	operator> (const T1 &x1, const Element< S2, T2 > &x2)
template<typename S1, typename T1, typename T2>
bool	operator>= (const Element< S1, T1 > &x1, const T2 &x2)
template<typename T1, typename S2, typename T2>
bool	operator>= (const T1 &x1, const Element< S2, T2 > &x2)
template<typename S1, typename T1, typename T2>
bool	operator<= (const Element< S1, T1 > &x1, const T2 &x2)
template<typename T1, typename S2, typename T2>
bool	operator<= (const T1 &x1, const Element< S2, T2 > &x2)
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<class Auto>
std::deque< hstate_t >	choose_n_states (const Auto &a, unsigned n)
static unsigned	alea (unsigned max)
template<typename Auto, typename TransitionConverter, typename Format>
io::automaton_saver_< Auto, TransitionConverter, Format >	automaton_saver (const Auto &, const TransitionConverter &e=TransitionConverter(), const Format &f=Format())
template<typename Auto, typename TransitionConverter, typename Format>
io::automaton_loader_< Auto, TransitionConverter, Format >	automaton_loader (Auto &a, const TransitionConverter &e=TransitionConverter(), const Format &f=Format(), bool merge_states=false)
template<typename S, typename T>
xml::xml_session &	op_rin (S &, xml::xml_session &, T &)
template<typename S, typename T>
xml::xml_session &	op_rout (const S &, xml::xml_session &, const T &)
template<class IStream>
IStream &	operator>> (IStream &, xml::xml_session &)
template<class OStream>
OStream &	operator<< (OStream &, const xml::xml_session &)
Variables
algebra::RationalNumber	identity_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber))
algebra::RationalNumber	zero_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber))
algebra::RationalNumber	identity_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber))
algebra::RationalNumber	zero_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber))
const rat::exp< Tm, Tw > &	identity_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >))
const rat::exp< Tm, Tw > &	zero_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >))
const algebra::polynom< Tm, Tw > &	identity_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >))
const algebra::polynom< Tm, Tw > &	zero_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >))

---

Detailed Description

CPP guard should not be inserted here as VCSN_CONTEXT_NAMESPACE could be changed.

Bug:

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

---

Function Documentation

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

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

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

Bug: FIXME: Add the following transformation in a separated function. Definition at line 159 of file krat.hxx. References exp::base(), op_in_mul(), and Series::semiring().

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

Bug: FIXME: Add the following transformation in a separated function. Definition at line 459 of file krat.hxx. References exp::base(), identity_value, op_convert(), precondition, SELECT, Series::semiring(), and zero_value.

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

Bug: FIXME: Add the following transformation in a separated function. Definition at line 550 of file krat.hxx. References exp::base(), identity_value, precondition, SELECT, Series::semiring(), and zero_value.

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(). Referenced by BerrySethiAlgo::BerrySethiAlgo().

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

Transform an automaton labeled with series to an automaton where all labels are series with one and only one element. 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 148 of file cut_up.hxx. References do_cut_up(), SELECT, and Element::structure(). Referenced by do_sub_normalize().

void cut_up (  const Element< S, T > &  a, Element< S, T > &  res )

Transform an automaton labeled with series to an automaton where all labels are series with one and only one element. 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 161 of file cut_up.hxx. References do_cut_up(), SELECT, and Element::structure().

void cut_up_here (  Element< S, T > &  a  )

Transform an automaton labeled with series to an automaton where all labels are series with one and only one element. 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 171 of file cut_up.hxx. References do_cut_up(), SELECT, and Element::structure(). Referenced by realtime_words_here().

void vcsn::do_eps_removal_here (  const AutomataBase< A_ > &  , Auto &  a, bool  bck_fwd )

Bug: FIXME: This converters should be removed Definition at line 34 of file eps_removal.hxx. References result_not_computable_if, and starable(). Referenced by backward_eps_removal(), backward_eps_removal_here(), eps_removal(), eps_removal_here(), forward_eps_removal(), and forward_eps_removal_here().

bool has_successors (  const Element< A, T > &  a, const hstate_t  s )

Whether a state has successors. Parameters: a  Automaton. s  State. Returns: True is the state s has successors. Definition at line 39 of file has_neighbour.hxx. References precondition. Referenced by do_is_normalized().

bool has_predecessors (  const Element< A, T > &  a, const hstate_t  s )

Whether a state has predecessors. Parameters: a  Automaton. s  State. Returns: True is the state s has predecessors. Definition at line 49 of file has_neighbour.hxx. References precondition. Referenced by 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 > &   )

Invert a transducer. Parameters: t  Input transducer. Returns: Inverse transducer.

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

This function creates a transposed view of an automaton. See also: transpose(), TransposeView Definition at line 48 of file transpose_view.hxx. References Element::structure(), and Element::value(). Referenced by do_coaccessible_states(), and transpose().

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

This function creates a transposed view of an automaton. See also: transpose(), TransposeView Definition at line 56 of file transpose_view.hxx. References Element::structure(), and Element::value().

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

Delta with a query and iterator output. Store the output transitions of the state 'from' where query(label(e)) is true using 'res'. Definition at line 379 of file transpose_view.hxx. References IdentityView::object(), and op_rdelta().

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

Delta on a letter with iterator output. Store the output transitions of the state 'from' where the label matches the letter. Definition at line 391 of file transpose_view.hxx. References IdentityView::object(), and op_letter_rdelta().

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

Delta with a query and container output. Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'. Definition at line 427 of file transpose_view.hxx. References IdentityView::object(), and op_rdeltac().

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

Delta on a letter with container output. Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'. Definition at line 439 of file transpose_view.hxx. References IdentityView::object(), and op_letter_rdeltac().

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

Delta with no condition and iterator output. Store the output states of the state 'from' using 'res'. Definition at line 464 of file transpose_view.hxx. References IdentityView::object(), and op_rdelta().

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

Delta using a query, with iterator output. Store the output states of the state 'from' where query(label(e)) is true using 'res'. Definition at line 474 of file transpose_view.hxx. References IdentityView::object(), and op_rdelta().

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

Delta on a letter with iterator output. Store the output states of the state 'from' where the label matches the letter. Definition at line 485 of file transpose_view.hxx. References IdentityView::object(), and op_letter_rdelta().

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

Delta without condition, container output. Store the output states of the state 'from' in the container 'res'. Definition at line 510 of file transpose_view.hxx. References IdentityView::object(), and op_rdeltac().

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

Delta with a query, using container output. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'. Definition at line 518 of file transpose_view.hxx. References IdentityView::object(), and op_rdeltac().

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

Delta on a letter, with container output. Store the output states of the state 'from' where query(label(e)) is true in the container 'res'. Definition at line 529 of file transpose_view.hxx. References IdentityView::object(), and op_letter_rdeltac().

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

Reverse delta without condition, and iterator output. Store the output transitions of the state 'from' using 'res'. Definition at line 554 of file transpose_view.hxx. References IdentityView::object(), and op_delta().

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

Reverse delta with query, with iterator output. Store the output transitions of the state 'from' where query(label(e)) is true using 'res'. Definition at line 563 of file transpose_view.hxx. References IdentityView::object(), and op_delta().

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

Reverse delta on a letter, with iterator output. Store the output transitions of the state 'from' where the label matches the letter. Definition at line 573 of file transpose_view.hxx. References IdentityView::object(), and op_letter_delta().

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

Reverse delta on a container, with no condition. Store the output transitions of the state 'from' in the container 'res'. Definition at line 597 of file transpose_view.hxx. References IdentityView::object(), and op_deltac().

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

Reverse delta using a query, with container output. Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'. Definition at line 604 of file transpose_view.hxx. References IdentityView::object(), and op_deltac().

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

Reverse delta on a letter, with container output. Store the output transitions of the state 'from' where query(label(e)) is true in the container 'res'. Definition at line 614 of file transpose_view.hxx. References IdentityView::object(), and op_letter_deltac().

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

Reverse delta using a query, with iterator output. Store the output states of the state 'from' where query(label(e)) is true using 'res'. Definition at line 647 of file transpose_view.hxx. References IdentityView::object(), and op_delta().

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

Reverse delta on a letter, with iterator output. Store the output states of the state 'from' where the label matches the letter. Definition at line 657 of file transpose_view.hxx. References IdentityView::object(), and op_letter_delta().

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

Reverse delta on a container, with no conditions. Store the output states of the state 'from' in the container 'res' Definition at line 681 of file transpose_view.hxx. References IdentityView::object(), and op_deltac().

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

Reverse delta in a container, with a query. Store the output states of the state 'from' where query(label(e)) is true in the container 'res' Definition at line 688 of file transpose_view.hxx. References IdentityView::object(), and op_deltac().

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

Reverse delta in a container, on a letter. Store in the container 'res' the output states of the state 'from' where query(label(e)) is true. Definition at line 698 of file transpose_view.hxx. References IdentityView::object(), and op_letter_deltac().

---