- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

# Algorithms

## Files
file | accessible.hh
| Algorithms for accessible/coaccessible states computation.

file | aci_canonical.hh
| Declaration for the canonical() algorithm.

file | aut_to_exp.hh
| Author: Yann Régis-Gianas <yann@lrde.epita.fr>

file | backward_realtime.hh
| Algorithms to make an automaton realtime.

file | complement.hh
| Complementation algorithm for Boolean automata.

file | complete.hh
| Completion algorithm for deterministic and Boolean automaton.

file | composition_cover.hh
| Author: Guillaume Leroi

file | concatenate.hh
| This file provides the general concatenation algorithm.

file | derived_term_automaton.hh
| Provides a converter from expression to automaton based on derivatives.

file | determinize.hh
| Boolean automata determinization.

file | domain.hh
| Domain algorithm.

file | eps_removal.hh
| This files declares the backward and forward eps_removal algorithm.

file | eps_removal_sp.hh
| This files declares the backward and forward eps_removal algorithm.

file | equivalent.hh
| This file contains the declarations for the are_equivalent() algorithm.

file | eval.hh
| Author: Yann Régis-Gianas <yann@lrde.epita.fr>

file | evaluation_fmp.hh
| Evaluation over normalized and sub-normalized transducers seen as automata over a free monoid product.

file | extension.hh
| Declarations for extension().

file | finite_support_conversion.hh
| Conversion between finite support application types.

file | fmp_to_realtime.hh
| This file provides a transformation function that computes the equivalent transducer of a FMP automaton.

file | forward_realtime.hh
| Algorithms to make an automaton realtime.

file | image.hh
| Image projection for transducers.

file | initial_derivation.hh
| Declaration of the initial derivation visitor, used for smart_derivative_automaton.

file | evaluation.hh
| Undocumented stuff.

file | outsplitting.hh
| Outsplitting and insplitting algorithms for normalized and sub-normalized fmp_transducers.

file | is_ambiguous.hh
| Test for ambiguity.

file | is_deterministic.hh
| Boolean automata determinization.

file | is_letterized.hh
| Letter-to-letter feature testing.

file | is_normalized.hh
| Test for transducer normalization.

file | isomorph.hh
| Author: Rodrigo de Souza <arsouza@enst.fr>

file | krat_exp_cderivation.hh
| Declaration for the cderivate() algorithms.

file | krat_exp_constant_term.hh
| Declaration for the constant_term() algorithm.

file | krat_exp_derivation.hh
| Declaration for the derivate() algorithms.

file | krat_exp_flatten.hh
| This file holds the declaration of the flatten() algorithm.

file | krat_exp_linearize.hh
| Declarations for the linearize() algorithm.

file | krat_exp_partial_derivation.hh
| Declarations for the partial_derivate() algorithm.

file | krat_exp_realtime.hh
| Declarations of the realtime() algorithm for rational expressions.

file | letter_to_letter_composition.hh
| Undocumented stuff.

file | minimization_hopcroft.hh
| This file provides minimization and quotient algorithms.

file | minimization_moore.hh
| This file containes the declaration of minimization_moore().

file | normalized.hh
| Thompson normalization operations.

file | normalized_composition.hh
| Composition for normalized and sub-normalized transducers seen as automata over a free monoid product.

file | product.hh
| Declarations of product().

file | projection.hh
| Undocumented stuff.

file | realtime.hh
| General algorithms concerning realtime aspect of automata.

file | realtime_composition.hh
| Undocumented stuff.

file | realtime_decl.hh
| Declaration of the realtime() function.

file | realtime_to_fmp.hh
| This file provides a transformation function that computes the equivalent FMP automaton of a tranducer.

file | search.hh
| Rational expression search in text.

file | standard.hh
| Several algorithms concerning standard automata.

file | standard_of.hh
| This file provides a converter from expression to standard automaton.

file | sub_automaton.hh
| This file provides the extraction of sub automaton.

file | sub_normalize.hh
| Sub-normalization algorithm for FMP transducers.

file | sum.hh
| Summing of automata.

file | thompson.hh
| The thompson automaton.

file | algorithms/transpose.hh
| This file contain the function which transpose an automaton.

file | trim.hh
| Declaration of useful_states() and trim().

## Classes
struct | KRatExpFlatten
struct | linearize_element
| The types of a linearized expression. More...
struct | FindBestSearch
| Specific implementation for search(). More...
struct | WindowedBackSearch
| Specific implementation for search(). More...
## 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 > > &m)
| Returns the determinized of a Boolean automaton.
## FMP automaton to realtime transducer algorithm.
Compute the equivalent transducer of a FMP automaton. Please note that for the moment this function works only if the support of each transition is finite. Algorithm : If the FMP contains transitions with "complex" expression (E), i.e. infinite support, then Thompson of E. With the resulting automaton apply a conversion. i.e. (a,x) -> a|x
template<typename S, typename T, typename SS, typename TT>
Element< SS, TT > & | fmp_to_realtime (const Element< S, T > &fmp, Element< SS, TT > &res)
## Product algorithm
Precondition: is_realtime. 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, const bool use_geometry=false)
template<typename A, typename T, typename U>
Element< A, T > | product (const Element< A, T > &lhs, const Element< A, U > &rhs, std::map< hstate_t, std::pair< hstate_t, hstate_t > > &, const bool use_geometry=false)
## 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.
## 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_set_elt_t | aut_to_exp (const Element< A, T > &a)
| Returns a series which describes the language of the automaton.
template<typename A, typename T, typename Chooser_>
Element< A, T >::series_set_elt_t | aut_to_exp (const Element< A, T > &a, const Chooser_ &c)
| Returns a series which describes the language of the automaton.
template<typename A, typename T>
void | backward_realtime_here (Element< A, T > &a)
| In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T > | backward_realtime (const Element< A, T > &a)
| Returns a fresh realtime automaton.
template<typename A, typename T, typename Exp>
void | berry_sethi (Element< A, T > &, const Exp &)
| Build an automaton from an expression using the Berry-Sethi construction.
template<typename A, typename T, typename Exp>
void | brzozowski (Element< A, T > &, const Exp &)
| Build an automaton from an expression using the Brzozowski construction.
template<typename A, typename T>
void | 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>
Element< S, T > | composition_co_cover (const Element< S, T > &fmp)
| Facade for composition co-cover.
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 | derived_term_automaton (Element< A, T > &a, const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A, typename T, typename Exp>
Element< A, T > | derived_term_automaton (const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A, typename T, typename Exp>
Element< A, T > | broken_derived_term_automaton (const Exp &e)
| Convert a krat expression into an automaton using derivatives.
template<typename A, typename T>
void | eps_removal_here (Element< A, T > &a, misc::direction_type dir=misc::backward)
| 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, misc::direction_type dir=misc::backward)
| 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<typename A, typename T>
void | eps_removal_here_sp (Element< A, T > &a, misc::direction_type dir=misc::backward)
| In place eps_removal_sp of an automaton (default is backward eps_removal).
template<typename A, typename T>
Element< A, T > | eps_removal_sp (const Element< A, T > &a, misc::direction_type dir=misc::backward)
| Eps_Removal of an automaton (default is backward eps_removal).
template<typename A, typename T>
void | backward_eps_removal_here_sp (Element< A, T > &a)
| In place backward eps_removal_sp of an automaton.
template<typename A, typename T>
Element< A, T > | backward_eps_removal_sp (const Element< A, T > &a)
| Backward eps_removal_sp of an automaton.
template<typename A, typename T>
void | forward_eps_removal_here_sp (Element< A, T > &a)
| In place forward eps_removal_sp of an automaton.
template<typename A, typename T>
Element< A, T > | forward_eps_removal_sp (const Element< A, T > &a)
| Forward eps_removal_sp of an automaton.
template<typename S, typename A, typename B>
bool | are_equivalent (const Element< S, A > &a, const Element< S, B > &b)
| Returns true iff the two boolean automata are equivalents, i.e., if they recognize the same language.
template<typename A, typename 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_fmp (const Element< ST, TT > &, const Element< SA, TA > &, Element< SARET, TARET > &)
| Evaluation over normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
identity_transducer_helper< S, T >::ret | extension (const Element< S, T > &)
| Extend an automaton to a transducer.
template<typename SA, typename TA, typename ST, typename TT>
Element< ST, TT > | extension (const Element< SA, TA > &, const Element< ST, TT > &)
| Extend an automaton to a transducer.
template<typename S, typename T, typename Ss, typename Ts>
void | finite_support_convert (Element< S, T > &dst, const Element< Ss, Ts > &org)
| Finite support conversion.
template<typename A, typename T>
void | forward_realtime_here (Element< A, T > &a)
| In place modification of the automaton to make it realtime.
template<typename A, typename T>
Element< A, T > | forward_realtime (const Element< A, T > &a)
| Returns a fresh realtime automaton.
template<typename 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 S, typename A>
bool | is_ambiguous (const Element< S, A > &aut)
| Test the ambiguity of automaton.
template<typename A, typename T>
bool | is_deterministic (const Element< A, T > &a)
| Test if an automaton is deterministic.
template<typename S, typename A>
bool | is_letterized_transducer (const Element< S, A > &t)
| Test the letter to letter features.
template<typename S, typename A>
bool | is_normalized_transducer (const Element< S, A > &t)
| Test the normalization of transducer.
template<typename A, typename T>
bool | are_isomorphic (const Element< A, T > &a, const Element< A, T > &b)
| Returns true if the two automata are isomorphic.
template<class Series, class T, class Letter>
Element< Series, T > | cderivate (const Element< Series, T > &exp, Letter a)
| The c-derivative of the krat expression w.r.t to a letter.
template<class Series, class T, class Word>
Element< Series, T > | word_cderivate (const Element< Series, T > &exp, Word a)
| The c-derivative of the krat expression w.r.t to a word.
template<class Series, class T>
std::pair< typename Element < Series, T >::semiring_elt_t, bool > | constant_term (const Element< Series, T > &exp)
| Return the constant term of the krat expression.
template<class Series, class T, class Letter>
std::pair< Element< Series, T >, bool > | derivate (const Element< Series, T > &exp, Letter a)
| The antimirov derivative of the krat expression w.r.t to a letter.
template<class Series, class T, class Word>
std::pair< Element< Series, T >, bool > | word_derivate (const Element< Series, T > &exp, Word a)
| The antimirov derivative of the krat expression w.r.t to a word.
template<class Series, class T>
std::list< typename Series::monoid_t::alphabet_t::letter_t > | flatten (const Element< Series, T > &exp)
| This algorithm extracts the letters from a rational expression.
template<class Series, class T>
linearize_element< Series, T > ::element_t | linearize (const Element< Series, T > &exp)
| The linearization of the krat expression.
template<class Series, class T, class Letter>
std::pair< std::set< Element < Series, T > >, bool > | partial_derivate (const Element< Series, T > &exp, Letter a)
| The partial derivative of the krat expression w.r.t to a letter.
template<class S, class T>
Element< S, T > | letter_to_letter_composition (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Undocumented.
template<typename A, typename T>
Element< A, T > | minimization_hopcroft (const Element< A, T > &a)
| Return the minimal automaton using the hopcroft algorithm.
template<typename A, typename T>
Element< A, T > | quotient (const Element< A, T > &a)
| Return the quotient of a non-deterministic acceptor.
template<typename A, typename T>
Element< A, T > | minimization_moore (const Element< A, T > &a)
| Returns the minimal deterministic automaton associated to the input one.
template<typename A, typename T>
Element< A, T > | co_minimization_moore (const Element< A, T > &a)
| Returns the co-minimal co-deterministic automaton associated to the input one.
template<typename A, typename T>
void | minimization_moore_here (Element< A, T > &a)
| Minimalize the deterministic input automaton.
template<typename A, typename T>
void | co_minimization_moore_here (Element< A, T > &a)
| Co-minimalize the co-deterministic input automaton.
template<typename A, typename T>
Element< A, T > | normalize (const Element< A, T > &a)
| Return the fresh thompson-normalized automaton.
template<typename A, typename T>
void | normalize_here (Element< A, T > &a)
| In-place normalize to the thompson form.
template<typename A, typename T>
bool | is_normalized (const Element< A, T > &a)
| Return true if the input automaton is thompson-normalized.
template<typename A, typename T, typename U>
void | union_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs)
| Do the in-place union of two thompson-normalized automata.
template<typename A, typename T, typename U>
Element< A, T > | union_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs)
| Return the fresh union of two thompson-normalized automata.
template<typename A, typename T, typename U>
void | concatenate_of_normalized_here (Element< A, T > &lhs, const Element< A, U > &rhs)
| Do the in-place concatenation of two thompson-normalized automata.
template<typename A, typename T, typename U>
Element< A, T > | concatenate_of_normalized (const Element< A, T > &lhs, const Element< A, U > &rhs)
| Return the fresh concatenation of two thompson-normalized automata.
template<typename A, typename T>
void | star_of_normalized_here (Element< A, T > &a)
| Do in-place star transformation on the thompson-normalized input.
template<typename A, typename T>
Element< A, T > | star_of_normalized (const Element< A, T > &a)
| Return the fresh star transformation of its normalized input.
template<typename S, typename T>
void | compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
Element< S, T > | compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
void | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs, Element< S, T > &ret)
| Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename S, typename T>
Element< S, T > | u_compose (const Element< S, T > &lhs, const Element< S, T > &rhs)
| Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.
template<typename auto_t, typename trans_t>
void | set_states (const trans_t &, auto_t &, std::map< hstate_t, hstate_t > &)
template<typename A, typename T>
void | realtime_here (Element< A, T > &a, misc::direction_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, misc::direction_type type)
| Returns a fresh realtime automaton.
template<typename S, typename T>
void | realtime_composition (const Element< S, T > &, const Element< S, T > &, Element< S, T > &)
| Composition for realtime transducers.
template<typename S, typename T>
Element< S, T > | realtime_composition (const Element< S, T > &, const Element< S, T > &)
| Composition for realtime transducers.
template<typename S, typename T>
Element< S, T > | realtime (const Element< S, T > &e)
| Calls the do_realtime function for rational expression or automata.
template<typename S, typename T>
void | realtime_here (Element< S, T > &e)
| Calls the do_realtime_here function for rational expression or automata.
template<typename S, typename T>
bool | is_realtime (const Element< S, T > &e)
| Test whether an automaton or a regular expression is realtime.
template<class InputIterator, class FoundFunctor, class Series, class T>
void | search (const Element< Automata< Series >, T > &a, const InputIterator &begin, const InputIterator &end, typename Element< Automata< Series >, T >::letter_t eol, FoundFunctor &f)
| Search for a rational expression into a text.
template<class Series, class T, class StatesSet>
static unsigned int | compute_distances (const Element< Automata< Series >, T > &a, std::vector< StatesSet > &distances)
| Compute distances from initial states to final states.
template<class InputIterator, class Series, class T, class StatesSet>
static std::pair< bool, unsigned int > | window_backsearch (const 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<typename A, typename T, typename Exp>
void | standard_of (Element< A, T > &a, const Exp &e)
| Convert a rational expression into a standard automaton.
template<typename A, typename T, typename Exp>
Element< A, T > | standard_of (const Exp &e)
| Convert a rational expression into a standard automaton.
template<typename A, typename T, typename StatesSet>
Element< A, T > | sub_automaton (const Element< A, T > &a, const StatesSet &s, bool check_states=true)
| Returns a fresh automaton that is the sub-automaton defined by a set.
template<typename A, typename T, typename StatesSet>
void | sub_automaton_here (Element< A, T > &a, const StatesSet &s, bool check_states=true)
| Select a sub-automaton into a given automaton.
template<class S, class T>
Element< S, T > | sub_normalize (const Element< S, T > &a)
| Sub-normalize a FMP transducer.
template<class S, class T1, class T2>
void | sub_normalize (const Element< S, T1 > &a, Element< S, T2 > &res)
| Sub-normalize a FMP transducer.
template<class S, class T>
void | sub_normalize_here (Element< S, T > &a)
| Sub-normalize a FMP transducer, in place version.
template<class S, class T>
bool | is_sub_normalized (const Element< S, T > &a)
| Check if a FMP transducer is sub-normalized.
template<typename A, typename T, typename U>
void | sum_here (Element< A, T > &lhs, const Element< A, U > &rhs)
| In place summing of two automata.
template<typename A, typename T, typename U>
Element< A, T > | sum (const Element< A, T > &lhs, const Element< A, U > &rhs)
| Summing of two automata.
template<typename A, typename T, typename Letter, typename Weight>
void | thompson_of (Element< A, T > &out, const rat::exp< Letter, Weight > &kexp)
| The Thompson automaton associated to the krat expression.
template<class AutoType, class S, class T>
Element< Automata< S >, AutoType > | thompson_of (const Element< S, T > &exp)
| The Thompson automaton associated to the krat expression.
template<typename lhs_t, typename rhs_t>
void | transpose (lhs_t &dst, const rhs_t &from)
| Transposition of an automaton.
template<typename auto_t>
auto_t | transpose (const auto_t &from)
| Return a fresh transposed automaton.
template<typename A, typename T>
std::set< hstate_t > | useful_states (const Element< A, T > &a)
| Returns a useful states of the automaton (start reachable and final co-).
template<typename A, typename T>
Element< A, T > | trim (const Element< A, T > &a)
| Return a fresh automaton in which non useful states are removed.
template<typename A, typename T>
void | trim_here (Element< A, T > &a)
| Trim a.

## Function Documentation

std::set< hstate_t > accessible_states | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 81 of file accessible.hxx.

References Element::structure().

Referenced by vcsn::accessible(), and vcsn::accessible_here().

Element< A, T > accessible | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 96 of file accessible.hxx.

References vcsn::accessible_states(), and vcsn::sub_automaton().

void accessible_here | ( | Element< A, T > & | a | ) | `[inline]`

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

Definition at line 89 of file accessible.hxx.

References vcsn::accessible_states(), and vcsn::sub_automaton_here().

std::set< hstate_t > coaccessible_states | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 115 of file accessible.hxx.

References Element::structure().

Referenced by vcsn::coaccessible(), and vcsn::coaccessible_here().

Element< A, T > coaccessible | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 122 of file accessible.hxx.

References vcsn::coaccessible_states(), and vcsn::sub_automaton().

void coaccessible_here | ( | Element< A, T > & | a | ) | `[inline]`

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

Definition at line 129 of file accessible.hxx.

References vcsn::coaccessible_states(), and vcsn::sub_automaton_here().

Element< A, T >::series_set_elt_t aut_to_exp | ( | const Element< A, T > & | a | ) | `[inline]`

Returns a series 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 series that describes the language of the automaton.

See also:
  generalized()

Definition at line 365 of file aut_to_exp.hxx.

Element< A, T >::series_set_elt_t aut_to_exp | ( | const Element< A, T > & | a,
|  | const Chooser_ & | c |
| ) |  |  | `[inline]`

Returns a series 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 work on.
  | c | An object-function that returns the next state to remove from the current state and the automaton.

Returns:
  A rational series that describes the language of the automaton.

See also:
  generalized()

Definition at line 356 of file aut_to_exp.hxx.

References Element::structure().

void backward_realtime_here | ( | Element< A, T > & | a | ) | `[inline]`

In place modification of the automaton to make it realtime.

Make an automaton realtime, using backward version of eps_removal for building.

Parameters:

  | a | The automaton to make realtime.

See also:
  realtime(), backward_realtime(), forward_realtime_here()

Definition at line 39 of file backward_realtime.hxx.

References Element::structure().

Element< A, T > backward_realtime | ( | const Element< A, T > & | a | ) | `[inline]`

Returns a fresh realtime automaton.

Build a fresh realtime automaton from those given, using backward version of eps_removal.

Parameters:

  | a | The automaton to make realtime.

See also:
  realtime(), backward_realtime_here(), forward_realtime()

Definition at line 57 of file backward_realtime.hxx.

References Element::structure().

void complement_here | ( | Element< A, T > & | a | ) | `[inline]`

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

Author:
  Yann Régis-Gianas

Definition at line 38 of file complement.hxx.

References vcsn::is_complete(), and vcsn::is_deterministic().

Referenced by vcsn::complement().

Element< A, T > complement | ( | const Element< A, T > & | a | ) | `[inline]`

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

Author:
  Yann Régis-Gianas

Definition at line 58 of file complement.hxx.

References vcsn::complement_here().

void complete_here | ( | Element< A, T > & | a | ) | `[inline]`

Make the transition function of an automaton total w.r.t alphabet.

Note:
  This algorithm works in place.

Parameters:

  | a | the deterministic and Boolean automaton to complete.

Precondition:
  a must be a realtime automaton

See also:
  complete(), is_complete()

Author:
  Yann Régis-Gianas

Definition at line 37 of file complete.hxx.

References vcsn::is_realtime(), and Element::structure().

Referenced by vcsn::complete().

Element< A, T > complete | ( | const Element< A, T > & | a | ) | `[inline]`

Make the transition function of an automaton total w.r.t alphabet.

Note:
  This algorithm returns a fresh automaton.

Parameters:

  | a | the deterministic and Boolean automaton to complete.

Precondition:
  a must be a realtime automaton

See also:
  complete_here(), is_complete()

Author:
  Yann Régis-Gianas

Definition at line 75 of file complete.hxx.

References vcsn::complete_here().

bool is_complete | ( | const Element< A, T > & | a | ) | `[inline]`

Test if the transition function is complete for each state.

Parameters:

  | a | The Boolean automaton to test.

Returns:
  true if the transition function of e is complete w.r.t alphabet.

Precondition:
  a must be a realtime automaton

See also:
  complete(), complete_here()

Author:
  Yann Régis-Gianas

Definition at line 88 of file complete.hxx.

References vcsn::is_realtime(), and Element::structure().

Referenced by vcsn::complement_here().

Element< S, T > composition_cover | ( | const Element< S, T > & | fmp | ) | `[inline]`

Facade for composition cover.

Definition at line 70 of file composition_cover.hxx.

References Element::structure().

Element< A, T > concatenate | ( | const Element< A, T > & | lhs,
|  | const Element< A, T > & | rhs |
| ) |  |  | `[inline]`

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.

Definition at line 60 of file concatenate.hxx.

References Element::structure().

void concatenate_here | ( | Element< A, T > & | lhs,
|  | const Element< A, T > & | rhs |
| ) |  |  | `[inline]`

In place concatenation of two automata.

This function modifies lhs to concatenate the language L(rhs) to its language.

It returns the concatenation of two automata using epsilon transitions.

Parameters:

  | lhs | The first automaton.
  | rhs | The second automaton.

See also:
  concatenate()

Author:
  Yann Regis-Gianas.

Definition at line 69 of file concatenate.hxx.

References Element::structure().

void derived_term_automaton | ( | Element< A, T > & | a,
|  | const Exp & | e |
| ) |  |  | `[inline]`

Convert a krat expression into an automaton using derivatives.

This algorithm produces an automaton from an expression using the Brzozowski construction. This construction involves multiple derivations on the initial expression.

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.

Definition at line 164 of file derived_term_automaton.hxx.

Referenced by vcsn::derived_term_automaton().

Element< A, T > derived_term_automaton | ( | const Exp & | e | ) | `[inline]`

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.

Definition at line 174 of file derived_term_automaton.hxx.

References vcsn::derived_term_automaton().

Element< A, T > broken_derived_term_automaton | ( | const Exp & | e | ) | `[inline]`

Convert a krat expression into an automaton using derivatives.

Derivations are first performed on the starting expression with the following formulae: d(0)={0}, d(1)={1}, d(a)={a} for all a in the alphabet, d(E+F)=d(E) union d(F), d(E.F)=[d(E)].F, d(E*)={E*}

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.

Definition at line 215 of file derived_term_automaton.hxx.

Element< A, T > determinize | ( | const Element< A, T > & | a | ) | `[inline]`

Returns the determinized of a Boolean automaton.

Parameters:

  | a | The Boolean automaton to determinize.

See also:
  ETA p114-117

Precondition:
  is Boolean automaton.

Returns:
  A fresh Boolean automaton that is the determinization of 'a'.

Definition at line 163 of file determinize.hxx.

Element< A, T > determinize | ( | const Element< A, T > & | a,
|  | std::map< hstate_t, std::set< hstate_t > > & | m |
| ) |  |  | `[inline]`

Returns the determinized of a Boolean automaton.

Parameters:

  | a | The Boolean automaton to determinize.
  | m | A map which will be augmented with the correspondance from one state of the resulting automaton to the set of states of the input automaton.

See also:
  ETA p114-117

Precondition:
  is Boolean automaton.

Returns:
  A fresh Boolean automaton that is the determinization of 'a'.

Definition at line 153 of file determinize.hxx.

References Element::structure().

void eps_removal_here | ( | Element< A, T > & | a,
|  | misc::direction_type | dir = `misc::backward` |
| ) |  |  | `[inline]`

In place eps_removal of an automaton (default is backward eps_removal).

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the Floyd/McNaughton/Yamada algorithm.

Parameters:

  | a | The weighted automaton to close.
  | dir | The orientation of the eps_removal.

See also:
  eps_removal(), forward_eps_removal(), forward_eps_removal_here(), backward_eps_removal(), backward_eps_removal_here()

Author:
  Sylvain Lombardy

Definition at line 432 of file eps_removal.hxx.

References SELECT, and Element::structure().

Referenced by vcsn::do_u_compose().

Element< A, T > eps_removal | ( | const Element< A, T > & | a,
|  | misc::direction_type | dir = `misc::backward` |
| ) |  |  | `[inline]`

Eps_Removal of an automaton (default is backward eps_removal).

This algorithm completes the given automaton into a copy to make it close over epsilon transition.

It is based on the Floyd/McNaughton/Yamada algorithm.

Parameters:

  | a | The weighted automaton to close.
  | dir | The orientation of the eps_removal.

See also:
  eps_removal_here(), forward_eps_removal(), forward_eps_removal_here(), backward_eps_removal(), backward_eps_removal_here()

Author:
  Sylvain Lombardy

Definition at line 444 of file eps_removal.hxx.

References SELECT, and Element::structure().

void backward_eps_removal_here | ( | Element< A, T > & | a | ) | `[inline]`

In place backward eps_removal of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the Floyd/McNaughton/Yamada algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  backward_eps_removal(), eps_removal_here(), eps_removal(), forward_eps_removal_here(), forward_eps_removal()

Author:
  Sylvain Lombardy

Definition at line 458 of file eps_removal.hxx.

References SELECT, and Element::structure().

Element< A, T > backward_eps_removal | ( | const Element< A, T > & | a | ) | `[inline]`

Backward eps_removal of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the Floyd/McNaughton/Yamada algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  backward_eps_removal_here(), eps_removal(), eps_removal_here(), forward_eps_removal(), forward_eps_removal_here()

Author:
  Sylvain Lombardy

Definition at line 470 of file eps_removal.hxx.

References SELECT, and Element::structure().

void forward_eps_removal_here | ( | Element< A, T > & | a | ) | `[inline]`

In place forward eps_removal of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the Floyd/McNaughton/Yamada algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  forward_eps_removal(), eps_removal_here(), eps_removal(), backward_eps_removal_here(), backward_eps_removal()

Author:
  Sylvain Lombardy

Definition at line 484 of file eps_removal.hxx.

References SELECT, and Element::structure().

Element< A, T > forward_eps_removal | ( | const Element< A, T > & | a | ) | `[inline]`

Forward eps_removal of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the Floyd/McNaughton/Yamada algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  forward_eps_removal_here(), eps_removal(), eps_removal_here(), backward_eps_removal(), backward_eps_removal_here()

Author:
  Sylvain Lombardy

Definition at line 496 of file eps_removal.hxx.

References SELECT, and Element::structure().

void eps_removal_here_sp | ( | Element< A, T > & | a,
|  | misc::direction_type | dir = `misc::backward` |
| ) |  |  | `[inline]`

In place eps_removal_sp of an automaton (default is backward eps_removal).

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the shortest-path algorithm.

Parameters:

  | a | The weighted automaton to close.
  | dir | The orientation of the eps_removal.

See also:
  eps_removal(), forward_eps_removal(), forward_eps_removal_here(), backward_eps_removal(), backward_eps_removal_here()

Author:
  Vivien Delmon

Definition at line 312 of file eps_removal_sp.hxx.

References SELECT, and Element::structure().

Element< A, T > eps_removal_sp | ( | const Element< A, T > & | a,
|  | misc::direction_type | dir = `misc::backward` |
| ) |  |  | `[inline]`

Eps_Removal of an automaton (default is backward eps_removal).

This algorithm completes the given automaton into a copy to make it close over epsilon transition.

It is based on the shortest-path algorithm.

Parameters:

  | a | The weighted automaton to close.
  | dir | The orientation of the eps_removal.

See also:
  eps_removal_here(), forward_eps_removal(), forward_eps_removal_here(), backward_eps_removal(), backward_eps_removal_here()

Author:
  Vivien Delmon

Definition at line 324 of file eps_removal_sp.hxx.

References SELECT, and Element::structure().

void backward_eps_removal_here_sp | ( | Element< A, T > & | a | ) | `[inline]`

In place backward eps_removal_sp of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the shortest-path algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  backward_eps_removal(), eps_removal_here(), eps_removal(), forward_eps_removal_here(), forward_eps_removal()

Author:
  Vivien Delmon

Definition at line 338 of file eps_removal_sp.hxx.

References SELECT, and Element::structure().

Element< A, T > backward_eps_removal_sp | ( | const Element< A, T > & | a | ) | `[inline]`

Backward eps_removal_sp of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the shortest-path algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  backward_eps_removal_here(), eps_removal(), eps_removal_here(), forward_eps_removal(), forward_eps_removal_here()

Author:
  Vivien Delmon

Definition at line 350 of file eps_removal_sp.hxx.

References SELECT, and Element::structure().

void forward_eps_removal_here_sp | ( | Element< A, T > & | a | ) | `[inline]`

In place forward eps_removal_sp of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the shortest-path algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  forward_eps_removal(), eps_removal_here(), eps_removal(), backward_eps_removal_here(), backward_eps_removal()

Author:
  Vivien Delmon

Definition at line 364 of file eps_removal_sp.hxx.

References SELECT, and Element::structure().

Element< A, T > forward_eps_removal_sp | ( | const Element< A, T > & | a | ) | `[inline]`

Forward eps_removal_sp of an automaton.

This algorithm completes in place the given automaton to make it close over epsilon transition.

It is based on the shortest-path algorithm.

Parameters:

  | a | The weighted automaton to close.

See also:
  forward_eps_removal_here(), eps_removal(), eps_removal_here(), backward_eps_removal(), backward_eps_removal_here()

Author:
  Vivien Delmon

Definition at line 376 of file eps_removal_sp.hxx.

References SELECT, and Element::structure().

bool are_equivalent | ( | const Element< S, A > & | a,
|  | const Element< S, B > & | b |
| ) |  |  | `[inline]`

Returns true iff the two boolean automata are equivalents, i.e., if they recognize the same language.

Definition at line 75 of file equivalent.hxx.

References Element::structure().

Element< A, T >::semiring_elt_t eval | ( | const Element< A, T > & | a,
|  | const W & | word |
| ) |  |  | `[inline]`

Return the image of a word by an automaton.

eval(a, w) returns a series that is the image of the word 'w' in the automaton. This version of computation is the most general one : it works on every types of automaton, deterministic or not. Yet, the automaton must be realtime.

Definition at line 105 of file eval.hxx.

References Element::structure().

identity_transducer_helper< S, T >::ret extension | ( | const Element< S, T > & | a | ) | `[inline]`

Extend an automaton to a transducer.

Extend an automaton to a transducer whose multiplicity is the series of the automaton.

Definition at line 113 of file extension.hxx.

References Element::structure().

Element< ST, TT > extension | ( | const Element< SA, TA > & | a,
|  | const Element< ST, TT > & | t |
| ) |  |  | `[inline]`

Extend an automaton to a transducer.

Extend an automaton to a transducer whose set is the one of another transducer passed in the second argument. This extension is required if we want to make a product of an automaton with a transducer. If this is not the case, we need simply call extension(automaton_t) above.

Definition at line 206 of file extension.hxx.

References Element::structure().

void finite_support_convert | ( | Element< S, T > & | dst,
|  | const Element< Ss, Ts > & | org |
| ) |  |  | `[inline]`

Finite support conversion.

This algorithm copies the value of a finite support application to another, possibly changing its type.

Parameters:

  | org | The source application to convert.
  | dst | The destination application.

Definition at line 30 of file finite_support_conversion.hxx.

References Element::structure().

void forward_realtime_here | ( | Element< A, T > & | a | ) | `[inline]`

In place modification of the automaton to make it realtime.

Make an automaton realtime, using forward version of eps_removal for building.

Parameters:

  | a | The automaton to make realtime.

See also:
  realtime(), forward_realtime(), backward_realtime_here()

Definition at line 38 of file forward_realtime.hxx.

References Element::structure().

Element< A, T > forward_realtime | ( | const Element< A, T > & | a | ) | `[inline]`

Returns a fresh realtime automaton.

Build a fresh realtime automaton from those given, using forward version of eps_removal.

Parameters:

  | a | The automaton to make realtime.

See also:
  realtime(), forward_realtime_here(), backward_realtime()

Definition at line 57 of file forward_realtime.hxx.

References Element::structure().

bool vcsn::is_ambiguous | ( | const Element< S, A > & | aut | ) | `[inline]`

Test the ambiguity of automaton.

Note:
  A trim automaton `A` is ambiguous if there exists a word `f` which is the label of two distinct accepting paths `A`.

Parameters:

  | aut | The automaton to test.

Returns:
  true if the automaton is ambiguous.

bool is_deterministic | ( | const Element< A, T > & | a | ) | `[inline]`

Test if an automaton is deterministic.

Parameters:

  | a | A Boolean automaton.

Precondition:
  a is a realtime Boolean automaton.

Returns:
  true if 'a' is deterministic.

Definition at line 97 of file is_deterministic.hxx.

Referenced by vcsn::complement_here().

bool is_letterized_transducer | ( | const Element< S, A > & | t | ) | `[inline]`

Test the letter to letter features.

Parameters:

  | t | The transducer to test.

Returns:
  true if the transducer is letter to letter.

Definition at line 50 of file is_letterized.hxx.

References Element::structure().

bool is_normalized_transducer | ( | const Element< S, A > & | t | ) | `[inline]`

Test the normalization of transducer.

Parameters:

  | t | The transducer to test.

Returns:
  true if the transducer is normalized.

Definition at line 50 of file is_normalized.hxx.

References Element::structure().

std::list< typename Series::monoid_t::alphabet_t::letter_t > flatten | ( | const Element< Series, T > & | exp | ) | `[inline]`

This algorithm extracts the letters from a rational expression.

The flatten() function extracts the letters of a rational expression, keeping the order in which they appear in the expression. The result is just a std::list of letters, with letters having the same type as the expression's letter, i.e. Element<S, T>::monoid_elt_t::set_t::alphabet_t::letter_t.

Parameters:

  | exp | The expression to work on.

Author:
  Thomas Claveirole <thomas.claveirole@lrde.epita.fr>

Definition at line 123 of file krat_exp_flatten.hxx.

References KRatExpFlatten::flatten().

Element< A, T > minimization_hopcroft | ( | const Element< A, T > & | a | ) | `[inline]`

Return the minimal automaton using the hopcroft algorithm.

Minimize a with Hopcroft algorithm.

Parameters:

  | a | The deterministic Boolean automaton to minimize.

Returns:
  A fresh automaton that is the canonical minimal automaton of 'a'.

Parameters:

  | a | The automaton.

Precondition:
  a Should be deterministic.

Returns:

Definition at line 286 of file minimization_hopcroft.hxx.

References Element::structure().

Element< A, T > quotient | ( | const Element< A, T > & | a | ) | `[inline]`

Return the quotient of a non-deterministic acceptor.

This algorithms works with both Boolean and weighted automata.

Parameters:

  | a | The automaton to minimize.

Returns:
  A fresh automaton that is the quotient of 'a'.

Definition at line 858 of file minimization_hopcroft.hxx.

References SELECT.

Element< A, T > minimization_moore | ( | const Element< A, T > & | a | ) | `[inline]`

Returns the minimal deterministic automaton associated to the input one.

Use Moore's algorithm to compute the minimal equivalent deterministic automaton. The complexity of this algorithm is O(n2). See minimize_hopcroft for O(nlogn).

See also:
  http://cs.engr.uky.edu/~lewis/essays/compilers/min-fa.html

  ETA p123-125

Precondition:
  is Boolean automaton and is deterministic.

Bug:
  Put the precondition.

Definition at line 241 of file minimization_moore.hxx.

References Element::structure().

Element< A, T > co_minimization_moore | ( | const Element< A, T > & | a | ) | `[inline]`

Returns the co-minimal co-deterministic automaton associated to the input one.

Use Moore's algorithm to compute the minimal equivalent co-deterministic automaton. The complexity of this algorithm is O(n2).

See also:
  http://cs.engr.uky.edu/~lewis/essays/compilers/min-fa.html

  ETA p123-125

Precondition:
  is Boolean automaton and is co-deterministic.

Bug:
  Put the precondition.

Definition at line 260 of file minimization_moore.hxx.

References Element::structure().

void minimization_moore_here | ( | Element< A, T > & | a | ) | `[inline]`

Minimalize the deterministic input automaton.

Use Moore's algorithm to minimalize (in place) the input automaton. The complexity of this algorithm is O(n2). See minimize_hopcroft for O(nlogn).

See also:
  http://cs.engr.uky.edu/~lewis/essays/compilers/min-fa.html

  ETA p123-125

Precondition:
  is Boolean automaton and is deterministic.

Definition at line 231 of file minimization_moore.hxx.

References Element::structure().

void co_minimization_moore_here | ( | Element< A, T > & | a | ) | `[inline]`

Co-minimalize the co-deterministic input automaton.

Use Moore's algorithm to co-minimalize (in place) the input automaton. The complexity of this algorithm is O(n2). See minimize_hopcroft for O(nlogn).

See also:
  http://cs.engr.uky.edu/~lewis/essays/compilers/min-fa.html

  ETA p123-125

Precondition:
  is Boolean automaton and is co-deterministic.

Definition at line 250 of file minimization_moore.hxx.

References Element::structure().

Element< A, T > normalize | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 61 of file normalized.hxx.

References Element::structure().

void normalize_here | ( | Element< A, T > & | a | ) | `[inline]`

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

Definition at line 70 of file normalized.hxx.

References Element::structure().

bool is_normalized | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 167 of file normalized.hxx.

References Element::structure().

void union_of_normalized_here | ( | Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 120 of file normalized.hxx.

References Element::structure().

Element< A, T > union_of_normalized | ( | const Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 129 of file normalized.hxx.

References Element::structure().

void concatenate_of_normalized_here | ( | Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 244 of file normalized.hxx.

References Element::structure().

Element< A, T > concatenate_of_normalized | ( | const Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 253 of file normalized.hxx.

References Element::structure().

void star_of_normalized_here | ( | Element< A, T > & | a | ) | `[inline]`

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:

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

Definition at line 289 of file normalized.hxx.

References Element::structure().

Element< A, T > star_of_normalized | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 296 of file normalized.hxx.

References Element::structure().

void compose | ( | const Element< S, T > & | lhs,
|  | const Element< S, T > & | rhs,
|  | Element< S, T > & | ret |
| ) |  |  | `[inline]`

Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.

Parameters:

  | lhs | The left hand side transducer.
  | rhs | The right hand side transducer.
  | ret | The result transducer.

Definition at line 422 of file normalized_composition.hxx.

References SELECT, and Element::structure().

Referenced by vcsn::do_compose(), and vcsn::do_u_compose().

Element< S, T > compose | ( | const Element< S, T > & | lhs,
|  | const Element< S, T > & | rhs |
| ) |  |  | `[inline]`

Composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.

Parameters:

  | lhs | The left hand side transducer.
  | rhs | The right hand side transducer.

Definition at line 442 of file normalized_composition.hxx.

References SELECT, and Element::structure().

void u_compose | ( | const Element< S, T > & | lhs,
|  | const Element< S, T > & | rhs,
|  | Element< S, T > & | ret |
| ) |  |  | `[inline]`

Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.

Parameters:

  | lhs | The left hand side transducer.
  | rhs | The right hand side transducer.
  | ret | The result transducer.

Definition at line 476 of file normalized_composition.hxx.

References vcsn::do_u_compose(), and Element::structure().

Element< S, T > u_compose | ( | const Element< S, T > & | lhs,
|  | const Element< S, T > & | rhs |
| ) |  |  | `[inline]`

Unambiguous composition for weighted normalized and sub-normalized transducers, seen as automata over a free monoid product.

Parameters:

  | lhs | The left hand side transducer.
  | rhs | The right hand side transducer.

Definition at line 493 of file normalized_composition.hxx.

References vcsn::do_u_compose(), and Element::structure().

void set_states | ( | const trans_t & | fmp_trans,
|  | auto_t & | res,
|  | std::map< hstate_t, hstate_t > & | stmap |
| ) |  |  | `[inline]`

Definition at line 28 of file projection.hxx.

void vcsn::realtime_here | ( | Element< A, T > & | a,
|  | misc::direction_type | type |
| ) |  |  | `[inline]`

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,
|  | misc::direction_type | type |
| ) |  |  | `[inline]`

Returns a fresh realtime automaton.

As `realtime_here`, it build a realtime automaton, but it returns a new one instead of changing the given one.

Parameters:

  | a | The automaton to make realtime.
  | type | The type of algorithm used.

See also:
  realtime_here(), forward_realtime(), backward_realtime()

Definition at line 207 of file realtime.hxx.

References Element::structure().

Element< S, T > realtime | ( | const Element< S, T > & | e | ) | `[inline]`

Calls the do_realtime function for rational expression or automata.

This function is a wrapper which select a realtime either from realtime.hh or from krat_exp_realtime.hh.

When called upon an automaton, this function uses the functions declared in realtime.hh to make this automaton realtime using the forward_realtime() algorithm.

When called with a rational expression, a function from krat_exp_realtime.hh is selected to expand words in the expression as a product of a letter.

See also:
  krat_exp_realtime.hh, realtime.hh

Definition at line 26 of file realtime_decl.hxx.

References Element::structure().

void realtime_here | ( | Element< S, T > & | e | ) | `[inline]`

Calls the do_realtime_here function for rational expression or automata.

This function is a wrapper which select a realtime either from realtime.hh or from krat_exp_realtime.hh.

It behaves exactly as realtime(), but do the operation in place.

See also:
  realtime()

Definition at line 33 of file realtime_decl.hxx.

References Element::structure().

bool is_realtime | ( | const Element< S, T > & | e | ) | `[inline]`

Test whether an automaton or a regular expression is realtime.

This function returns true if the input is realtime.

Parameters:

  | e | The automaton or regular expression to test.

See also:
  realtime()

Definition at line 40 of file realtime_decl.hxx.

References Element::structure().

Referenced by vcsn::complete_here(), and vcsn::is_complete().

vcsn::Element< SS, TT > & realtime_to_fmp | ( | const Element< S, T > & | trans,
|  | vcsn::Element< SS, TT > & | res |
| ) |  |  | `[inline]`

Compute the equivalent FMP automaton of a transducer.

Please note that for the moment this function works only if the support of each transition is finite.

Preconditions : The transducer is realtime. The weight of each transition must have a finite support.

Definition at line 247 of file realtime_to_fmp.hxx.

References Element::structure().

void search | ( | const Element< Automata< Series >, T > & | a,
|  | const InputIterator & | begin,
|  | const InputIterator & | end,
|  | typename Element< Automata< Series >, T >::letter_t | eol,
|  | FoundFunctor & | f |
| ) |  |  | `[inline]`

Search for a rational expression into a text.

This function searches a rational expression into a text, given a iterator on the text and an automaton which recognizes the corresponding langage. The result cannot spread over two lines.

Parameters:

  | a | The automaton which recognizes the searched words.
  | begin | An input iterator to the begining of the text.
  | end | An iterator to the end of the text.
  | eol | The character to use for ending a line.
  | f | A functor with an operator () method taking 3 InputIterator as argument which will be called each time a match is found. the first one points to the begining of the stream. The two following ones are respectively the first and the last position of the match in the stream.

Authors:
  Thomas Claveirole <thomas@lrde.epita.fr>

Bug:
  Multiple implementations of search() should be implemented. When a call to search is performed an heuristic should decide which implementation to use. For the moment there is no such mechanism since only one implementation of search is provided.

Definition at line 31 of file search.hxx.

static unsigned int vcsn::compute_distances | ( | const Element< Automata< Series >, T > & | a,
|  | std::vector< StatesSet > & | distances |
| ) |  |  | `[inline, static]`

Compute distances from initial states to final states.

For each i, compute the set of states reachable in i steps or less. the result is stored into a vector of set of states distances[i]. This algorithm stops when it first encounter a final state. The last i value is returned.

Definition at line 66 of file search.hxx.

static std::pair<bool, unsigned int> vcsn::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 |
| ) |  |  | `[inline, static]`

Back search inside a window.

Returns whether the window is a potential match for the given automaton or not as the first element of the pair. The second element is the maximal value we can use to shift the window without skipping matches.

Parameters:

  | w | The window.
  | a | The automaton to use.
  | distances | Distances get from compute_distances().

See also:
  search(), build_reverse_factor_automaton(), compute_distances()

Definition at line 124 of file search.hxx.

void standardize | ( | Element< A, T > & | a | ) | `[inline]`

Returns a standard automaton associated to the input.

Parameters:

  | a | The automaton to standardize

See also:
  is_standard()

Definition at line 83 of file standard.hxx.

References Element::structure().

bool is_standard | ( | const Element< A, T > & | a | ) | `[inline]`

Returns true if the input automaton is standard.

Parameters:

  | a | The automaton to test

See also:
  standardize()

Definition at line 178 of file standard.hxx.

References Element::structure().

void union_of_standard_here | ( | Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 133 of file standard.hxx.

References Element::structure().

Referenced by vcsn::union_of_standard().

Element< A, T > union_of_standard | ( | const Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 142 of file standard.hxx.

References vcsn::union_of_standard_here().

void concat_of_standard_here | ( | Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 262 of file standard.hxx.

Element< A, T > concat_of_standard | ( | const Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

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

Definition at line 271 of file standard.hxx.

References Element::structure().

void star_of_standard_here | ( | Element< A, T > & | a | ) | `[inline]`

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

Definition at line 313 of file standard.hxx.

Element< A, T > star_of_standard | ( | const Element< A, T > & | a | ) | `[inline]`

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

Definition at line 320 of file standard.hxx.

References Element::structure().

void standard_of | ( | Element< A, T > & | a,
|  | const Exp & | e |
| ) |  |  | `[inline]`

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.

Definition at line 225 of file standard_of.hxx.

References Element::structure().

Referenced by vcsn::standard_of().

Element< A, T > standard_of | ( | const Exp & | e | ) | `[inline]`

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.

Definition at line 233 of file standard_of.hxx.

References vcsn::standard_of().

Element< A, T > sub_automaton | ( | const Element< A, T > & | a,
|  | const StatesSet & | s,
|  | bool | check_states = `true` |
| ) |  |  | `[inline]`

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.

Returns:
  A fresh sub-automaton.

See also:
  sub_automaton_here()

Definition at line 56 of file sub_automaton.hxx.

References Element::structure().

Referenced by vcsn::accessible(), vcsn::coaccessible(), and vcsn::trim().

void sub_automaton_here | ( | Element< A, T > & | a,
|  | const StatesSet & | s,
|  | bool | check_states = `true` |
| ) |  |  | `[inline]`

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

Definition at line 64 of file sub_automaton.hxx.

References Element::structure().

Referenced by vcsn::accessible_here(), vcsn::coaccessible_here(), vcsn::do_u_compose(), and vcsn::trim_here().

Element< S, T > sub_normalize | ( | const Element< S, T > & | a | ) | `[inline]`

Sub-normalize a FMP transducer.

- a Input automaton.
  Returns:
    Sub-normalized automaton.

Definition at line 219 of file sub_normalize.hxx.

void vcsn::sub_normalize | ( | const Element< S, T1 > & | a,
|  | Element< S, T2 > & | res |
| ) |  |  | `[inline]`

Sub-normalize a FMP transducer.

- a Input automaton.
- res Output automaton.

void sub_normalize_here | ( | Element< S, T > & | a | ) | `[inline]`

Sub-normalize a FMP transducer, in place version.

Parameters:

  | a | Input automaton.

Definition at line 237 of file sub_normalize.hxx.

References Element::structure().

bool is_sub_normalized | ( | const Element< S, T > & | a | ) | `[inline]`

Check if a FMP transducer is sub-normalized.

- a Input automaton.
  Returns:
    boolean.

Definition at line 243 of file sub_normalize.hxx.

References Element::structure().

void sum_here | ( | Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

In place summing of two automata.

This function adds states and transitions of an automaton to states and transitions of a second automaton.

Parameters:

  | lhs | Destination of the summing
  | rhs | Source of summing

See also:
  sum()

Definition at line 88 of file sum.hxx.

References Element::structure().

Element< A, T > sum | ( | const Element< A, T > & | lhs,
|  | const Element< A, U > & | rhs |
| ) |  |  | `[inline]`

Summing of two automata.

This function returns the fresh union of two automata. It put transitions 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()

Definition at line 96 of file sum.hxx.

References Element::structure().

void thompson_of | ( | Element< A, T > & | out,
|  | const rat::exp< Letter, Weight > & | kexp |
| ) |  |  | `[inline]`

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

Definition at line 174 of file thompson.hxx.

References Element::structure().

Referenced by vcsn::thompson_of().

Element< Automata< S >, AutoType > thompson_of | ( | const Element< S, T > & | exp | ) | `[inline]`

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

Definition at line 182 of file thompson.hxx.

References Element::structure(), vcsn::thompson_of(), and Element::value().

void transpose | ( | lhs_t & | dst,
|  | const rhs_t & | from |
| ) |  |  | `[inline]`

Transposition of an automaton.

This function copy in `dst` the transposition of the automaton `from`.

Parameters:

  | from | Automaton to transpose
  | dst | Destination

Definition at line 27 of file algorithms/transpose.hxx.

References vcsn::transpose_view().

auto_t transpose | ( | const auto_t & | from | ) | `[inline]`

Return a fresh transposed automaton.

This function returns the transposition of an automaton.

Parameters:

  | from | Automaton to transpose.

Definition at line 39 of file algorithms/transpose.hxx.

References vcsn::transpose().