Algorithms

Compounds
struct	linearize_element
	The types of a linearized expression. More...
Enumerations
enum	realtime_type
	Enum to indicate which kind of realtime algorithms must be used.
Functions
template<typename A, typename T> std::set< hstate_t >	accessible_states (const Element< A, T > &a)
	Return accessible states.
template<typename A, typename T> Element< A, T >	accessible (const Element< A, T > &a)
	Extract the sub-automaton composed of accessible states.
template<typename A, typename T> void	accessible_here (Element< A, T > &a)
	In-place extract the sub-automaton of accessible states.
template<typename A, typename T> std::set< hstate_t >	coaccessible_states (const Element< A, T > &a)
	Return co-accessible states.
template<typename A, typename T> Element< A, T >	coaccessible (const Element< A, T > &a)
	Extract the sub-automaton composed of co-accessible states.
template<typename A, typename T> void	coaccessible_here (Element< A, T > &a)
	In-place extract the sub-automaton of co-accessible states.
template<class Series, class T> Element< Series, T >	canonical (const Element< Series, T > &exp)
	Transform a krat expression into its canonical form, following aci-rules.
template<typename A, typename T> Element< A, T >::series_elt_t	aut_to_exp (const Element< A, T > &a)
	Returns a serie which describes the language of the automaton.
template<typename A, typename T, typename Chooser_> Element< A, T >::series_elt_t	aut_to_exp (const Element< A, T > &a, const Chooser_ &c)
	Returns a serie which describes the language of the automaton.
template<typename A, typename T> void	backward_closure_here (Element< A, T > &a)
	Complete in place the given automaton to make it close over epsilon transition.
template<typename A, typename T> Element< A, T >	backward_closure (const Element< A, T > &a)
	Complete the given automaton into a copy to make it close over epsilon transition.
template<typename A, typename T> void	backward_realtime_here (Element< A, T > &a)
	In place modification of the automaton to make it realtime.
template<typename A, typename T> Element< A, T >	backward_realtime (const Element< A, T > &a)
	Returns a fresh realtime automaton.
template<typename A, typename T, typename Exp> void	berry_sethi (Element< A, T > &, const Exp &)
	Convert a krat expression into an automaton using.
template<typename A, typename T, typename Exp> void	brzozowski (Element< A, T > &, const Exp &)
	Convert a krat expression into an automaton using Brzozowski construction.
template<typename A, typename T> void	complement_here (Element< A, T > &a)
	Complement in place the set of final states.
template<typename A, typename T> Element< A, T >	complement (const Element< A, T > &a)
	Complement in place 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 > &)
	Make the transition function of an automaton total w.r.t alphabet.
template<class A, class T> bool	is_complete (const Element< A, T > &e)
	Test if the transition function is complete for each state.
template<class A, class T> Element< A, T >	concatenate (const Element< A, T > &lhs, const Element< A, T > &rhs)
	Return the concatenation of two automata.
template<class A, class T> void	concatenate_here (Element< A, T > &lhs, const Element< A, T > &rhs)
	In place concatenation of two automata.
template<typename A, typename T, typename Exp> void	derivatives_automaton (Element< A, T > &a, const Exp &e)
	Convert a krat expression into an automaton using derivatives.
template<typename A, typename T, typename Exp> Element< A, T >	derivatives_automaton (const Exp &e)
	Convert a krat expression into an automaton using derivatives.
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> bool	is_deterministic (const Element< A, T > &a)
	Test if an automaton is deterministic.
template<typename A, typename T, typename W> Element< A, T >::weight_t	eval (const Element< A, T > &a, const W &word)
	Compute the image of a word into an automaton.
template<typename A, typename T> void	forward_closure_here (Element< A, T > &a)
	Complete the given automaton into a copy to make it close over epsilon transition.
template<typename A, typename T> Element< A, T >	forward_closure (const Element< A, T > &a)
	Complete the given automaton into a copy to make it close over epsilon transition.
template<typename A, typename T> void	forward_realtime_here (Element< A, T > &a)
	In place modification of the automaton to make it realtime.
template<typename A, typename T> Element< A, T >	forward_realtime (const Element< A, T > &a)
	Returns a fresh realtime automaton.
template<typename 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 S, typename A> bool	is_letterized_transducer (const Element< S, A > &t)
	Test the letter to letter features.
template<typename S, typename A> bool	is_normalized_transducer (const Element< S, A > &t)
	Test the normalization of transducer.
template<typename S, typename A> bool	is_realtime (const Element< S, A > &)
	Test to detect realtime transducers.
template<typename A, typename T> bool	is_isomorph (const Element< A, T > &a, const Element< A, T > &b)
	Returns true if the two automata are isomorph.
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 >::weight_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> 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 Series, class T> Element< Series, T >	realtime (const Element< Series, T > &exp)
	Expand words in the expression as a product of letters.
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 >	normalize (const Element< A, T > &a)
	Return the fresh thompson-normalized automaton.
template<typename A, typename T> void	normalize_here (Element< A, T > &a)
	In-place normalize to the thompson form.
template<typename A, typename T> bool	is_normalized (const Element< A, T > &a)
	Return true if the input automaton is thompson-normalized.
template<typename A, typename T, typename U> void	union_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	Do the in-place union of two thompson-normalized automata.
template<typename A, typename T, typename U> Element< A, T >	union_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return the fresh union of two thompson-normalized automata.
template<typename A, typename T, typename U> void	concatenate_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	Do the in-place concatenation of two thompson-normalized automata.
template<typename A, typename T, typename U> Element< A, T >	concatenate_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return the fresh concatenation of two thompson-normalized automata.
template<typename A, typename T> void	star_of_normalized_here (Element< A, T > &a)
	Do in-place star transformation on the thompson-normalized input.
template<typename A, typename T> Element< A, T >	star_of_normalized (const Element< A, T > &a)
	Return the fresh star transformation of its normalized input.
template<typename A, typename T, typename U> Element< A, T >	product (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Returns a fresh automaton that is the product of the two input ones.
template<typename A, typename T> bool	is_realtime (const Element< A, T > &a)
	Test whether an automaton is realtime.
template<typename A, typename T> void	realtime_here (Element< A, T > &a, realtime_type type=forward)
	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=forward)
	Returns a fresh realtime automaton.
template<typename A, typename T> void	standardize (Element< A, T > &a)
	Returns a standard automaton associated to the input.
template<typename A, typename T> bool	is_standard (const Element< A, T > &a)
	Returns true if the input automaton is standard.
template<typename A, typename T, typename U> void	union_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In-place union of two standard automata.
template<typename A, typename T, typename U> Element< A, T >	union_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return a fresh union of two standard automata.
template<typename A, typename T, typename U> void	concat_of_standard_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In-place concatenation of two standard automata.
template<typename A, typename T, typename U> Element< A, T >	concat_of_standard (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Return a fresh concatenation of two standard automata.
template<typename A, typename T> void	star_of_standard_here (Element< A, T > &a)
	In-place star transformation of a standard automata.
template<typename A, typename T> Element< A, T >	star_of_standard (const Element< A, T > &a)
	Return the fresh star transformation of a standard automata.
template<typename A, typename T, typename Exp> void	standard_of (Element< A, T > &a, const Exp &e)
	Convert a rational expression into a standard automaton.
template<typename A, typename T, typename Exp> Element< A, T >	standard_of (const Exp &e)
	Convert a rational expression into a standard automaton.
template<typename A, typename T, typename StatesSet> Element< A, T >	sub_automaton (const Element< A, T > &a, const StatesSet &s, bool check_states=true)
	Returns a fresh automaton that is the sub-automaton defined by a set.
template<typename A, typename T, typename StatesSet> void	sub_automaton_here (Element< A, T > &a, const StatesSet &s, bool check_states=true)
	Select a sub-automaton into a given automaton.
template<typename A, typename T, typename U> void	sum_here (Element< A, T > &lhs, const Element< A, U > &rhs)
	In place summing of two automata.
template<typename A, typename T, typename U> Element< A, T >	sum (const Element< A, T > &lhs, const Element< A, U > &rhs)
	Summing of two automata.
template<typename A, typename T, typename Letter, typename Weight> void	thompson_of (Element< A, T > &out, const rat::exp< Letter, Weight > &kexp)
	The Thompson automaton associated to the krat expression.
template<class AutoType, class S, class T> Element< Automata< S >, AutoType >	thompson_of (const Element< S, T > &exp)
	The Thompson automaton associated to the krat expression.
template<typename lhs_t, typename rhs_t> void	transpose (lhs_t &dst, const rhs_t &from)
	Transposition of an automaton.
template<typename auto_t> auto_t	transpose (const auto_t &from)
	Return a fresh transposed automaton.
template<typename A, typename T> std::set< hstate_t >	useful_states (const Element< A, T > &a)
	Returns a useful states of the automaton (start reachable and final co-).
template<typename A, typename T> Element< A, T >	trim (const Element< A, T > &a)
	Return a fresh automaton in which non useful states are removed.

---

Function Documentation

std::set<hstate_t> accessible_states (  const Element< A, T > &  a  )

Return accessible states. This functions returns the accessible states set of its input automaton. Parameters: a  The input automaton. See also: accessible(), coaccessible(), coaccessible_states()

Element<A, T> accessible (  const Element< A, T > &  a  )

Extract the sub-automaton composed of accessible states. This function returns a fresh sub-automaton of its input containing only accessible states. Parameters: a  The input automaton. See also: accessible_here(), accessible_states(), coaccessible(), coaccessible_states()

void accessible_here (  Element< A, T > &  a  )

In-place extract the sub-automaton of accessible states. This function computes the sub-autmaton of accessible states from its input automaton. The operation is performed in-place. Parameters: a  An in/out parameter which contains the automaton to work on as input and the result as output. See also: accessible(), accessible_states(), coaccessible(), coaccessible_states()

std::set<hstate_t> coaccessible_states (  const Element< A, T > &  a  )

Return co-accessible states. This functions returns the co-accessible states set of its input automaton, i.e. states which are accessible from final states. Parameters: a  The input automaton. See also: coaccessible(), accessible(), accessible_states()

Element<A, T> coaccessible (  const Element< A, T > &  a  )

Extract the sub-automaton composed of co-accessible states. This function returns a fresh sub-automaton of its input containing only co-accessible states, i.e. states which are accessible from final states. Parameters: a  The input automaton. See also: coaccessible_here(), coaccessible_states(), accessible(), accessible_states()

void coaccessible_here (  Element< A, T > &  a  )

In-place extract the sub-automaton of co-accessible states. This function computes the sub-autmaton of co-accessible states from its input automaton. The operation is performed in-place. Parameters: a  An in/out parameter which contains the automaton to work on as input and the result as output. See also: coaccessible(), coaccessible_states(), accessible(), accessible_states()

Element<A, T>::series_elt_t aut_to_exp (  const Element< A, T > &  a  )

Returns a serie which describes the language of the automaton. This algorithm works on every kind of series. However, if, during the computation, it must take the star of it, it can fail. By passing a "generalized" automaton, that is an automaton with rational expression as label, you will be sure to have the algorithm succeed since we can always take the star of a rational expression. Parameters: a  the automaton to convert. Returns: a rational serie that describes the language of the automaton. See also: generalized

Element<A, T>::series_elt_t aut_to_exp (  const Element< A, T > &  a, const Chooser_ &  c )

Returns a serie which describes the language of the automaton. This algorithm works on every kind of series. However, if, during the computation, it must take the star of it, it can fail. By passing a "generalized" automaton, that is an automaton with rational expression as label, you will be sure to have the algorithm succeed since we can always take the star of a rational expression. Parameters: c  a object-function that returns the next state to remove from the current state and the automaton. Returns: a rational serie that describes the language of the automaton. See also: generalized

void backward_closure_here (  Element< A, T > &  a  )

Complete in place the given automaton to make it close over epsilon transition. Parameters: a  the weighted automaton to close. See also: forward_closure_here forward_closure backward_closure_here

Element<A, T> backward_closure (  const Element< A, T > &  a  )

Complete the given automaton into a copy to make it close over epsilon transition. Parameters: a  the weighted automaton to close. See also: forward_closure forward_closure_here backward_closure_here

void backward_realtime_here (  Element< A, T > &  a  )

In place modification of the automaton to make it realtime. This function make an automaton realtime, using backward version of closure for building. Parameters: a  The automaton to make realtime. See also: realtime backward_realtime forward_realtime_here

Element<A, T> backward_realtime (  const Element< A, T > &  a  )

Returns a fresh realtime automaton. This fonction build a fresh realtime automaton from those given, using backward version of closure. Parameters: a  The automaton to make realtime. See also: realtime backward_realtime_here forward_realtime

void complement_here (  Element< A, T > &  a  )

Complement in place the set of final states. Parameters: a  the deterministic boolean automaton to complement. Note: the input automaton must be complete and deterministic. See also: complement.

Element<A, T> complement (  const Element< A, T > &  a  )

Complement in place the set of final states. Parameters: a  the deterministic boolean automaton to complement. Note: the input automaton must be complete and deterministic. See also: complement_here.

void complete_here (  Element< A, T > &  a  )

Make the transition function of an automaton total w.r.t alphabet. Work in place. Parameters: a  the deterministic and boolean automaton to complete. See also: complete. is_complete.

Element<A, T> complete (  const Element< A, T > &   )

Make the transition function of an automaton total w.r.t alphabet. Return a fresh automaton. Parameters: a  the deterministic and boolean automaton to complete. See also: complete_here. is_complete.

bool is_complete (  const Element< A, T > &  e  )

Test if the transition function is complete for each state. Parameters: a  the boolean automaton to test. Returns: true is the transition function of e is complete w.r.t alphabet. See also: complete. complete_here.

Element<A, T> concatenate (  const Element< A, T > &  lhs, const Element< A, T > &  rhs )

Return the concatenation of two automata. This function produces a new automata that realizes L(lhs).L(rhs). Parameters: lhs  the first automaton. rhs  the second automaton. See also: concatenate_here. Returns: a fresh automaton that is the concatenation of lhs and rhs.

void concatenate_here (  Element< A, T > &  lhs, const Element< A, T > &  rhs )

In place concatenation of two automata. This function modifies lhs to concatenate the language L(rhs) to its language. Parameters: lhs  the first automaton. rhs  the second automaton. See also: concatenate.

void derivatives_automaton (  Element< A, T > &  a, const Exp &  e )

Convert a krat expression into an automaton using derivatives. Parameters: a  an automaton to store the results. e  the expression to convert. Note: 'a' is generally an empty automaton. It enables the choice of the series to work with. Thus, the series can be different from the expresion ones.

Element<A, T> derivatives_automaton (  const Exp &  e  )

Convert a krat expression into an automaton using derivatives. Parameters: e  the expression to convert. Returns: a fresh automaton which recognizes the language denoted by 'e'. Note: The series of the expression are used to define the automaton.

Element<A, T> determinize (  const Element< A, T > &  a  )

Returns the determinized of a boolean automaton. Parameters: a  the boolean automaton to determinize. Returns: a fresh boolean automaton that is the determinization of 'a'.

bool is_deterministic (  const Element< A, T > &  a  )

Test if an automaton is deterministic. Parameters: a  a boolean automaton. Returns: true if 'a' is deterministic.

Element<A, T>::weight_t eval (  const Element< A, T > &  a, const W &  word )

Compute the image of a word into an automaton. eval(a, w) returns a weight that is the image of the word 'w' in the automaton. This algorithm works an weighted deterministic or not realtime automata. Parameters: a  the automaton. word  the word to give as an input to the automaton. Returns: the weight associated to the word

void forward_closure_here (  Element< A, T > &  a  )

Complete the given automaton into a copy to make it close over epsilon transition. Parameters: a  the weighted automaton to close. See also: forward_closure backward_closure backward_closure_here

Element<A, T> forward_closure (  const Element< A, T > &  a  )

Complete the given automaton into a copy to make it close over epsilon transition. Parameters: a  the weighted automaton to close. See also: forward_closure backward_closure backward_closure_here

void forward_realtime_here (  Element< A, T > &  a  )

In place modification of the automaton to make it realtime. This function make an automaton realtime, using forward version of closure for building. Parameters: a  The automaton to make realtime. See also: realtime forward_realtime backward_realtime_here

Element<A, T> forward_realtime (  const Element< A, T > &  a  )

Returns a fresh realtime automaton. This fonction build a fresh realtime automaton from those given, using forward version of closure. Parameters: a  The automaton to make realtime. See also: realtime forward_realtime_here backward_realtime

Element<A, T> minimization_hopcroft (  const Element< A, T > &  a  )

Return the minimal automaton using the hopcroft algorithm. Parameters: a  the deterministic boolean automaton to minimize. Returns: a fresh automaton that is the canonical minimal automaton of 'a'.

Element<A, T> quotient (  const Element< A, T > &  a  )

Return the quotient of a non deterministic acceptor. Parameters: a  the boolean automaton to minimize. Returns: a fresh automaton that is the quotient of 'a'.

bool is_letterized_transducer (  const Element< S, A > &  t  )

Test the letter to letter features. Parameters: t  the transducer to test. Returns: true if the transducer is letter to letter.

bool is_normalized_transducer (  const Element< S, A > &  t  )

Test the normalization of transducer. Parameters: t  the transducer to test. Returns: true if the transducer is normalized.

bool is_realtime (  const Element< S, A > &   )

Test to detect realtime transducers. Parameters: t  the transducer to test. Returns: true if the transducer is realtime.

Element<A, T> normalize (  const Element< A, T > &  a  )

Return the fresh thompson-normalized automaton. This function returns the thompson-normalized automaton corresponding to its input. Parameters: a  The automaton to normalize. See also: normalize_here(), is_normalized(), union_of_normalized(), concatenate_of_normalized(), star_of_normalized().

void normalize_here (  Element< A, T > &  a  )

In-place normalize to the thompson form. This function performs the in-place thompson-normalization of its input. Parameters: a  An in/out parameter containing the automaton to normalize as input, and the normalized automaton as output. See also: normalize, is_normalized(), union_of_normalized(), concatenate_of_normalized(), star_of_normalized().

bool is_normalized (  const Element< A, T > &  a  )

Return true if the input automaton is thompson-normalized. This function indicates whether its input automaton is thompson-normalized or not. Parameters: a  The automaton to test. See also: normalize(), union_of_normalized(), concatenate_of_normalized(), star_of_normalized().

void union_of_normalized_here (  Element< A, T > &  lhs, const Element< A, U > &  rhs )

Do the in-place union of two thompson-normalized automata. This function performs the in-place union of two thompson-normalized automata. The result is thompson-normalized. Parameters: lhs  An in/out parameter which is the left hand side of the union as input, and the operation result as output. rhs  Right hand side of the union. See also: union_of_normalized(), concatenate_of_normalized(), star_of_normalized(), normalize(), is_normalized().

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. This function returns a fresh automaton which is the union of input automata. It is thompson-normalized. Parameters: lhs  Left hand side of the union. rhs  Right hand side of the union. See also: union_of_normalized_here(), concatenate_of_normalized(), star_of_normalized(), normalize(), is_normalized().

void concatenate_of_normalized_here (  Element< A, T > &  lhs, const Element< A, U > &  rhs )

Do the in-place concatenation of two thompson-normalized automata. This function performs the in-place concatenation of two thompson-normalized automata. The result is thompson-normalized. Parameters: lhs  An in/out parameter which is the left hand side of the concatenation as input, and the operation result as output. rhs  Right hand side of the concatenation. See also: concatenate_of_normalized(), union_of_normalized(), star_of_normalized(), normalize(), is_normalized().

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. This function returns a fresh automaton which is the concatenation of input automata. It is thompson-normalized. Parameters: lhs  Left hand side of the concatenation. rhs  Right hand side of the concatenation. See also: concatenate_of_normalized_here(), union_of_normalized(), star_of_normalized(), normalize, is_normalized().

void star_of_normalized_here (  Element< A, T > &  a  )

Do in-place star transformation on the thompson-normalized input. This function performs the in-place star transformation of a thompson-normalized automaton. The result is thompson-normalized. Parameters: lhs  An in/out parameter which is the automaton to transform as input, and the operation result as output. See also: star_of_normalized(), concatenate_of_normalized(), union_of_normalized(), normalize(), is_normalized().

Element<A, T> star_of_normalized (  const Element< A, T > &  a  )

Return the fresh star transformation of its normalized input. This function performs a star transformation on its input, and returns it as a fresh automaton. The input must be thompson-normalized, and the result is thompson-normalized. Parameters: a  The automaton to run star transformation on. See also: star_of_normalized_here(), concatenate_of_normalized(), union_of_normalized(), normalize(), is_normalized().

bool is_realtime (  const Element< A, T > &  a  )

Test whether an automaton is realtime. This function returns true if the input automaton is realtime. Parameters: a  The automaton to test. See also: realtime

void realtime_here (  Element< A, T > &  a, realtime_type  type = forward )

In place modification of the automaton to make it realtime. This algorithm makes an automaton realtime. It calls forward_realtime or backward_realtime according to type given. The type may not be precised, it is the forward_realtime which is used by default. Parameters: a  The automaton to make realtime. type  The type of algorithm used. See also: realtime forward_realtime_here backward_realtime_here

Element<A, T> realtime (  const Element< A, T > &  a, realtime_type  type = forward )

Returns a fresh realtime automaton. As realtime_here, it build a realtime automaton, but it returns a new one instead of changing those given. Parameters: a  The automaton to make realtime. type  The type of algorithm used. See also: realtime_here forward_realtime backward_realtime

void standardize (  Element< A, T > &  a  )

Returns a standard automaton associated to the input. Parameters: a  The automaton to standardize See also: is_standard Bug: Not implemented yed

bool is_standard (  const Element< A, T > &  a  )

Returns true if the input automaton is standard. Parameters: a  The automaton to test See also: standardize

void union_of_standard_here (  Element< A, T > &  lhs, const Element< A, U > &  rhs )

In-place union of two standard automata. This function make the union of two standard automata. The result is a standard automaton. Parameters: lhs  The first automaton (will contain the result) rhs  The second automaton See also: standardize is_standard union_of_standard

Element<A, T> union_of_standard (  const Element< A, T > &  lhs, const Element< A, U > &  rhs )

Return a fresh union of two standard automata. As union_of_standard_here, this function build the union of two automatons, but it builds a new one. Parameters: lhs  The first automaton rhs  The second automaton See also: standardize is_standard union_of_standard_here

void concat_of_standard_here (  Element< A, T > &  lhs, const Element< A, U > &  rhs )

In-place concatenation of two standard automata. This function make the concatenation of two standard automata. The result is a standard automaton. Parameters: lhs  The first automaton (will contain the result) rhs  The second automaton See also: standardize is_standard concat_of_standard

Element<A, T> concat_of_standard (  const Element< A, T > &  lhs, const Element< A, U > &  rhs )

Return a fresh concatenation of two standard automata. As concat_of_standard_here, this function build the union of two automatons, but it builds a new one. Parameters: lhs  The first automaton rhs  The second automaton See also: standardize is_standard concat_of_standard_here

void star_of_standard_here (  Element< A, T > &  a  )

In-place star transformation of a standard automata. This function make the star transformation of a standard automaton, and replace those given by the result. Parameters: a  The automaton to transform See also: standardize is_standard star_of_standard

Element<A, T> star_of_standard (  const Element< A, T > &  a  )

Return the fresh star transformation of a standard automata. As star_of_standard_here, this function applies star on an automaton, but it build a new automaton. Parameters: a  The automaton on which star must be applied. See also: standardize is_standard star_of_standard_here

void standard_of (  Element< A, T > &  a, const Exp &  e )

Convert a rational expression into a standard automaton. Parameters: e  the expression to convert. a  the automaton to store the result. Note: the automaton is used to enable the use of different series from the expression.

Element<A, T> standard_of (  const Exp &  e  )

Convert a rational expression into a standard automaton. Parameters: e  the expression to convert. Returns: a standard automaton. Note: the automaton is defined using the series of the expression.

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. Parameters: a  the automaton into which we have to extract the sub-automaton. s  the set of states of the sub-automaton included in the state of 'a'. check_states  a flag to enable/disable the inclusion checking. See also: sub_automaton_here. Returns: a fresh sub-automaton.

void sub_automaton_here (  Element< A, T > &  a, const StatesSet &  s, bool  check_states = true )

Select a sub-automaton into a given automaton. Parameters: a  the automaton into which we have to extract the sub-automaton. s  the set of states of the sub-automaton included in the state of 'a'. check_states  a flag to enable/disable the inclusion checking. See also: sub_automaton.

void sum_here (  Element< A, T > &  lhs, const Element< A, U > &  rhs )

In place summing of two automata. This function adds states and edges of an automaton to states and edges of a second automaton. Parameters: lhs  Destination of the summing rhs  Source of summing See also: sum

Element<A, T> sum (  const Element< A, T > &  lhs, const Element< A, U > &  rhs )

Summing of two automata. This function returns the fresh union of two automata. It put edges and states of the two automata together, and create a news one with the result. Parameters: lhs  First automaton to sum rhs  Second automaton to sum See also: sum_here

void thompson_of (  Element< A, T > &  out, const rat::exp< Letter, Weight > &  kexp )

The Thompson automaton associated to the krat expression. This function build the automaton associated to the rational expression implemented by a krat_exp, using Thompson algorithm. Parameters: out  The resulting automaton kexp  The rational expression

Element<Automata<S>, AutoType> thompson_of (  const Element< S, T > &  exp  )

The Thompson automaton associated to the krat expression. This function build the automaton associated to the rational expression implemented by a krat_exp, using Thompson algorithm. The kind of returned automaton is a default one. Parameters: exp  The rational expression

void transpose (  lhs_t &  dst, const rhs_t &  from )

Transposition of an automaton. This function copy in dst the transposition of the automaton from. Parameters: from  Automaton to transpose dst  Destination

auto_t transpose (  const auto_t &  from  )

Return a fresh transposed automaton. This function returns the transposition of an automaton. Parameters: from  Automaton to transpose.

---