2.5/vcsn.htmldir/a00557_source.html

 #pragma once

 #include <iosfwd>
 #include <string>
 #include <vector>

 #include <boost/optional.hpp>

 #include <vcsn/algos/fwd.hh>
 #include <vcsn/ctx/fwd.hh>
 #include <vcsn/dyn/fwd.hh>
 #include <vcsn/dyn/types.hh>
 #include <vcsn/misc/export.hh>

 namespace vcsn
 {
   namespace dyn LIBVCSN_API
   {
     automaton accessible(const automaton& aut);

     automaton add(const automaton& lhs, const automaton& rhs,
                   const std::string& algo = "auto");

     expression add(const expression& lhs, const expression& rhs);

     expansion add(const expansion& lhs, const expansion& rhs);

     polynomial add(const polynomial& lhs, const polynomial& rhs);

     weight add(const weight& lhs, const weight& rhs);

     word ambiguous_word(const automaton& aut);

     bool are_equal(const automaton& lhs, const automaton& rhs);

     bool are_equal(const expression& lhs, const expression& rhs);

     bool are_equivalent(const automaton& lhs, const automaton& rhs);

     bool are_equivalent(const expression& lhs, const expression& rhs);

     bool are_isomorphic(const automaton& lhs, const automaton& rhs);

     automaton cerny(const context& ctx, unsigned num_states);

     automaton coaccessible(const automaton& aut);

     automaton codeterminize(const automaton& aut,
                             const std::string& algo = "auto");

     automaton cominimize(const automaton& aut,
                          const std::string& algo = "auto");

     int compare(const automaton& lhs, const automaton& rhs);

     int compare(const expression& lhs, const expression& rhs);

     int compare(const label& lhs, const label& rhs);

     int compare(const polynomial& lhs, const polynomial& rhs);

     int compare(const weight& lhs, const weight& rhs);

     automaton complement(const automaton& aut);

     expansion complement(const expansion& x);

     expression complement(const expression& r);

     automaton complete(const automaton& aut);

     automaton component(const automaton& aut, unsigned num);

     automaton compose(const automaton& lhs, const automaton& rhs,
                       bool lazy = false);

     expansion compose(const expansion& lhs, const expansion& rhs);

     expression compose(const expression& lhs, const expression& rhs);

     polynomial compose(const polynomial& lhs, const polynomial& rhs);

     expression concatenate(const expression& lhs, const expression& rhs);

     automaton condense(const automaton& aut);

     automaton conjunction(const automaton& lhs, const automaton& rhs,
                           bool lazy = false);

     automaton conjunction(const std::vector<automaton>& as,
                           bool lazy = false);

     automaton conjunction(const automaton& aut, unsigned n);

     expansion conjunction(const expansion& lhs, const expansion& rhs);

     expression conjunction(const expression& lhs, const expression& rhs);

     polynomial conjunction(const polynomial& lhs, const polynomial& rhs);

     automaton conjugate(const automaton& aut);

     std::string configuration(const std::string& key);

     weight constant_term(const expression& e);

     context context_of(const automaton& a);

     context context_of(const expansion& r);

     context context_of(const expression& r);

     context context_of(const polynomial& r);

     automaton copy(const automaton& aut);

     automaton copy(const automaton& aut, const context& ctx);

     expression copy(const expression& exp,
                     const context& ctx, identities ids);

     automaton costandard(const automaton& a);

     automaton cotrie(const polynomial& p);

     automaton cotrie(const context& ctx, std::istream& is,
                      const std::string& format = "default");

     automaton de_bruijn(const context& ctx, unsigned n);

     automaton delay_automaton(const automaton& a);

     polynomial derivation(const expression& exp, const label& lbl,
                           bool breaking = false);

     automaton derived_term(const expression& exp,
                            const std::string& algo = "auto");

     automaton determinize(const automaton& aut,
                           const std::string& algo = "auto");

     automaton difference(const automaton& lhs, const automaton& rhs);

     expression difference(const expression& lhs, const expression& rhs);

     automaton divkbaseb(const context& ctx, unsigned divisor, unsigned base);

     automaton double_ring(const context& ctx, unsigned n,
                           const std::vector<unsigned>& f);

     automaton eliminate_state(const automaton& aut,
                               int s = -1);

     weight evaluate(const automaton& aut, const word& l);

     weight evaluate(const automaton& aut, const polynomial& p);

     expression expand(const expression& e);

     expression expression_one(const context& c, identities ids);

     expression expression_zero(const context& c, identities ids);

     automaton factor(const automaton& aut);

     automaton filter(const automaton& aut, const std::vector<unsigned>& ss);

     automaton focus(const automaton& aut, unsigned tape);

     bool has_twins_property(const automaton& aut);

     bool has_lightening_cycle(const automaton& aut);

     bool has_bounded_lag(const automaton& aut);

     identities identities_of(const expression& exp);

     automaton inductive(const expression& e, const std::string& algo = "auto");

     automaton infiltrate(const automaton& lhs, const automaton& rhs);

     automaton infiltrate(const std::vector<automaton>& as);

     expression infiltrate(const expression& lhs, const expression& rhs);

     std::ostream& info(const automaton& aut, std::ostream& out = std::cout,
                        unsigned details = 2);

     std::ostream& info(const expression& exp, std::ostream& out = std::cout);

     automaton insplit(const automaton& aut, bool lazy = false);

     bool is_accessible(const automaton& aut);

     bool is_ambiguous(const automaton& aut);

     bool is_coaccessible(const automaton& aut);

     bool is_codeterministic(const automaton& aut);

     bool is_complete(const automaton& aut);

     bool is_costandard(const automaton& aut);

     bool is_cycle_ambiguous(const automaton& aut);

     bool is_deterministic(const automaton& aut);

     bool is_empty(const automaton& aut);

     bool is_eps_acyclic(const automaton& aut);

     bool is_functional(const automaton& aut);

     bool is_letterized(const automaton& aut);

     bool is_partial_identity(const automaton& aut);

     bool is_normalized(const automaton& aut);

     bool is_out_sorted(const automaton& aut);

     bool is_proper(const automaton& aut);

     bool is_realtime(const automaton& aut);

     bool is_standard(const automaton& aut);

     bool is_synchronized(const automaton& aut);

     bool is_synchronized_by(const automaton& aut, const word& word);

     bool is_synchronizing(const automaton& aut);

     bool is_trim(const automaton& aut);

     bool is_useless(const automaton& aut);

     bool is_valid(const automaton& e);

     bool is_valid(const expression& e);

     context join(const context& lhs, const context& rhs);

     automaton ladybird(const context& ctx, unsigned n);

     automaton ldivide(const automaton& lhs, const automaton& rhs);

     expansion ldivide(const expansion& lhs, const expansion& rhs);

     expression ldivide(const expression& lhs, const expression& rhs);

     label ldivide(const label& lhs, const label& rhs);

     polynomial ldivide(const polynomial& lhs, const polynomial& rhs);

     weight ldivide(const weight& lhs, const weight& rhs);

     polynomial lgcd(const polynomial& lhs, const polynomial& rhs);

     automaton lweight(const weight& w, const automaton& aut,
                         const std::string& algo = "auto");

     expansion lweight(const weight& w, const expansion& exp);

     expression lweight(const weight& w, const expression& exp);

     polynomial lweight(const weight& w, const polynomial& p);

     bool less_than(const automaton& lhs, const automaton& rhs);

     bool less_than(const expression& lhs, const expression& rhs);

     automaton letterize(const automaton& aut);

     automaton levenshtein(const context& ls);

     automaton lift(const automaton& aut,
                    const std::vector<unsigned>& tapes = {},
                    identities ids = {});

     expression lift(const expression& e);

     polynomial lightest(const automaton& aut, unsigned num = 1,
                         const std::string& algo = "auto");

     automaton lightest_automaton(const automaton& aut,
                                  unsigned num = 1,
                                  const std::string& algo = "auto");

     automaton make_automaton(const std::string& data,
                              const std::string& format = "default",
                              bool strip = true);

     automaton_editor* make_automaton_editor(const context& ctx);

     context make_context(const std::string& name);

     expression make_expression(const context& ctx,
                                const std::string& s, identities ids = {},
                                const std::string& format = "default");

     label make_label(const context& ctx, const std::string& s,
                      const std::string& format = "default");

     polynomial make_polynomial(const context& ctx, const std::string& s);

     weight make_weight(const context& ctx, const std::string& s);

     context make_word_context(const context& ctx);

     label make_word(const context& ctx, const std::string& s,
                     const std::string& format = "default");

     automaton multiply(const automaton& lhs, const automaton& rhs,
                        const std::string& algo = "auto");

     automaton multiply(const automaton& aut, int min, int max = -2,
                        const std::string& algo = "auto");

     expression multiply(const expression& lhs, const expression& rhs);

     expression multiply(const expression& e, int min, int max = -2);

     label multiply(const label& lhs, const label& rhs);

     label multiply(const label& l, int num);

     polynomial multiply(const polynomial& lhs, const polynomial& rhs);

     weight multiply(const weight& lhs, const weight& rhs);

     weight multiply(const weight& e, int min, int max = -2);

     automaton minimize(const automaton& aut,
                        const std::string& algo = "auto");

     automaton normalize(const automaton& aut);

     std::size_t num_components(const automaton& aut);

     std::size_t num_tapes(const context& ctx);

     automaton pair(const automaton& aut, bool keep_initials = false);

     automaton partial_identity(const automaton& aut);

     expression partial_identity(const expression& e);

     automaton prefix(const automaton& aut);

     std::ostream& print(const automaton& aut, std::ostream& out = std::cout,
                         const std::string& format = "default");

     std::ostream& print(const context& c, std::ostream& out = std::cout,
                         const std::string& format = "default");

     std::ostream& print(const expansion& e, std::ostream& out = std::cout,
                         const std::string& format = "default");

     std::ostream& print(const expression& e, std::ostream& out = std::cout,
                         const std::string& format = "default");

     std::ostream& print(const label& l, std::ostream& out = std::cout,
                         const std::string& format = "default");

     std::ostream& print(const polynomial& p, std::ostream& out = std::cout,
                         const std::string& format = "default");

     std::ostream& print(const weight& w, std::ostream& out = std::cout,
                         const std::string& format = "default");

     automaton quotkbaseb(const context& ctx, unsigned divisor, unsigned base);

     void set_format(std::ostream& out, const std::string& format);

     std::string get_format(std::ostream& out);

     automaton project(const automaton& aut, unsigned tape);

     context project(const context& ctx, unsigned tape);

     expansion project(const expansion& xpn, unsigned tape);

     expression project(const expression& exp, unsigned tape);

     polynomial project(const polynomial& p, unsigned tape);

     label project(const label& p, unsigned tape);

     automaton proper(const automaton& aut,
                      direction dir = direction::backward,
                      bool prune = true, const std::string& algo = "auto");

     automaton push_weights(const automaton& aut);

     automaton random_automaton(const context& ctx,
                                unsigned num_states,
                                float density = 0.1,
                                unsigned num_initial = 1,
                                unsigned num_final = 1,
                                boost::optional<unsigned> max_labels = {},
                                float loop_chance = 0.0,
                                const std::string& weights = "");

     automaton random_automaton_deterministic(const context& ctx,
                                              unsigned num_states);

     expression
     random_expression(const context& ctx,
                       const std::string& param = "+, ., *=.2, w., .w, length=10",
                       identities ids = {});

     weight random_weight(const context& ctx, const std::string& param);

     automaton rdivide(const automaton& lhs, const automaton& rhs);

     expression rdivide(const expression& lhs, const expression& rhs);

     label rdivide(const label& lhs, const label& rhs);

     weight rdivide(const weight& lhs, const weight& rhs);

     automaton read_automaton(std::istream& is,
                              const std::string& format = "default",
                              bool strip = true,
                              const location& loc = location{});

     expression read_expression(const context& ctx, identities ids,
                                std::istream& is,
                                const std::string& format = "default",
                                const location& loc = location{});

     label read_label(const context& ctx, std::istream& is,
                      const std::string& format = "default");

     polynomial read_polynomial(const context& ctx, std::istream& is);

     weight read_weight(const context& ctx, std::istream& is);

     automaton realtime(const automaton& aut);

     automaton reduce(const automaton& aut);

     automaton rweight(const automaton& aut, const weight& w,
                          const std::string& algo = "auto");

     expansion rweight(const expansion& aut, const weight& w);

     expression rweight(const expression& exp, const weight& w);

     polynomial rweight(const polynomial& p, const weight& w);

     automaton scc(const automaton& aut, const std::string& algo = "auto");

     polynomial shortest(const automaton& aut,
                         boost::optional<unsigned> num = {},
                         boost::optional<unsigned> len = {});

     automaton shuffle(const automaton& lhs, const automaton& rhs);

     automaton shuffle(const std::vector<automaton>& as);

     expression shuffle(const expression& lhs, const expression& rhs);

     automaton sort(const automaton& a);

     polynomial split(const expression& exp);

     polynomial split(const polynomial& p);

     automaton standard(const automaton& a);

     automaton standard(const expression& e);

     automaton star(const automaton& aut, const std::string& algo = "auto");

     unsigned star_height(const expression& rs);

     expression star_normal_form(const expression& e);

     automaton strip(const automaton& a);

     automaton suffix(const automaton& aut);

     automaton subword(const automaton& aut);

     automaton synchronize(const automaton& aut);

     word synchronizing_word(const automaton& aut,
                             const std::string& algo = "greedy");

     automaton thompson(const expression& e);

     automaton to_automaton(const expression& exp,
                            const std::string& algo = "auto");

     expansion to_expansion(const expression& exp);

     expression to_expression(const automaton& aut,
                              identities ids = {},
                              const std::string& algo = "auto");

     expression to_expression(const context& ctx, identities ids,
                              const label& l);

     expression to_expression(const context& ctx, identities ids,
                              const letter_class_t& letters,
                              bool accept = true);

     automaton transpose(automaton& aut);

     expression transpose(const expression& e);

     expression transposition(const expression& r);

     automaton trie(const polynomial& p);

     automaton trie(const context& ctx, std::istream& is,
                    const std::string& format = "default");

     automaton trim(const automaton& aut);

     automaton tuple(const automaton& lhs, const automaton& rhs);

     automaton tuple(const std::vector<automaton>& as);

     context tuple(const context& lhs, const context& rhs);

     context tuple(const std::vector<context>& ctxs);

     expansion tuple(const std::vector<expansion>& rs);

     expression tuple(const expression& lhs, const expression& rhs);

     expression tuple(const std::vector<expression>& rs);

     polynomial tuple(const std::vector<polynomial>& ps);

     std::string type(const automaton& a);

     automaton u(const context& ctx, unsigned n);

     automaton universal(const automaton& aut);

     weight weight_one(const context& c);

     weight weight_series(const automaton& aut);

     weight weight_zero(const context& c);

     automaton zpc(const expression& exp, const std::string& algo = "auto");

     std::ostream& operator<<(std::ostream& o, const automaton& a);

     std::ostream& operator<<(std::ostream& o, const context& c);

     std::ostream& operator<<(std::ostream& o, const expansion& e);

     std::ostream& operator<<(std::ostream& o, const expression& r);

     std::ostream& operator<<(std::ostream& o, const label& l);

     std::ostream& operator<<(std::ostream& o, const polynomial& p);

     std::ostream& operator<<(std::ostream& o, const weight& w);
   }
 }

 #include <vcsn/dyn/algos.hxx>
vcsn::dyn::ladybird
automaton ladybird(const context &ctx, unsigned n)
The ladybird automaton with n states.
Definition: ladybird.hh:54

vcsn::dyn::to_expression
expression to_expression(const automaton &aut, identities ids={}, const std::string &algo="auto")
An expression denoting the language of aut.
Definition: to-automaton.hh:184

vcsn::dyn::zpc
automaton zpc(const expression &exp, const std::string &algo="auto")
The ZPC automaton of exp.

vcsn::dyn::infiltrate
automaton infiltrate(const automaton &lhs, const automaton &rhs)
The infiltration of automata lhs and rhs.
Definition: others.cc:56

vcsn::dyn::coaccessible
automaton coaccessible(const automaton &aut)
The coaccessible subautomaton of aut.
Definition: accessible.hh:215

vcsn::dyn::star
automaton star(const automaton &aut, const std::string &algo="auto")
Star of an automaton.
Definition: star.hh:124

vcsn::dyn::is_synchronized_by
bool is_synchronized_by(const automaton &aut, const word &word)
Whether the word synchronizes aut.
Definition: synchronizing-word.hh:72

vcsn::dyn::u
automaton u(const context &ctx, unsigned n)
The Brzozowski universal witness.
Definition: u.hh:68

vcsn::dyn::subword
automaton subword(const automaton &aut)
Create a subword automaton from aut.
Definition: prefix.hh:174

vcsn::dyn::to_expansion
expansion to_expansion(const expression &exp)
First order development of a exp.

vcsn::dyn::identities
::vcsn::rat::identities identities
Sets of identities on expressions.
Definition: fwd.hh:17

vcsn::dyn::word
label word
The type of a word.
Definition: types.hh:26

vcsn::dyn::read_expression
expression read_expression(const context &ctx, identities ids, std::istream &is, const std::string &format="default", const location &loc=location{})
Read an expression from a stream.
Definition: read.cc:97

vcsn::dyn::make_word
label make_word(const context &ctx, const std::string &s, const std::string &format="default")
Build a word from a string.
Definition: algos.hxx:142

vcsn::dyn::trie
automaton trie(const polynomial &p)
A trie-like automaton (single initial state, multiple final states) to accept p.
Definition: trie.hh:242

vcsn::dyn::is_proper
bool is_proper(const automaton &aut)
Whether has no spontaneous transition.
Definition: is-proper.hh:58

vcsn::dyn::lweight
automaton lweight(const weight &w, const automaton &aut, const std::string &algo="auto")
The left-multiplication of an automaton with w as weight.
Definition: weight.hh:149

vcsn::dyn::label
value_impl< detail::label_tag > label
Definition: fwd.hh:32

vcsn::dyn::get_format
std::string get_format(std::ostream &out)
Get the output format for out.
Definition: print.cc:171

vcsn::dyn::project
automaton project(const automaton &aut, unsigned tape)
Keep a single tape from a multiple-tape automaton.
Definition: others.cc:113

vcsn::dyn::is_accessible
bool is_accessible(const automaton &aut)
Whether aut is accessible.
Definition: accessible.hh:233

vcsn::dyn::scc
automaton scc(const automaton &aut, const std::string &algo="auto")
Build the SCC automaton whose states are labeled with number of the strongly-connected component they...
Definition: scc.hh:704

vcsn::dyn::concatenate
expression concatenate(const expression &lhs, const expression &rhs)
Concatenate two expressions.

vcsn::dyn::is_costandard
bool is_costandard(const automaton &aut)
Whether is costandard (unique final state, with weight one, no outcoming transition).
Definition: standard.hh:63

vcsn::dyn::cotrie
automaton cotrie(const polynomial &p)
A reversed trie-like automaton (multiple initial states, single final state) automaton to accept p...
Definition: trie.hh:251

vcsn::dyn::normalize
automaton normalize(const automaton &aut)
Normalize automaton aut.
Definition: normalize.hh:41

vcsn::dyn::operator<<
std::ostream & operator<<(std::ostream &o, const automaton &a)
Output automaton a on o.
Definition: print.cc:178

vcsn::dyn::proper
automaton proper(const automaton &aut, direction dir=direction::backward, bool prune=true, const std::string &algo="auto")
An equivalent automaton without spontaneous transitions.
Definition: proper.hh:299

vcsn::dyn::expansion
value_impl< detail::expansion_tag > expansion
Definition: fwd.hh:30

vcsn::dyn::cominimize
automaton cominimize(const automaton &aut, const std::string &algo="auto")
The cominimized automaton.
Definition: minimize.hh:196

vcsn::dyn::divkbaseb
automaton divkbaseb(const context &ctx, unsigned divisor, unsigned base)
An automaton which accepts a word n representing a number in base b iff k|n.
Definition: divkbaseb.hh:69

vcsn::dyn::is_valid
bool is_valid(const automaton &e)
Whether automaton is valid (epsilon-cycles converge).
Definition: is-valid.hh:150

vcsn
Definition: a-star.hh:8

vcsn::dyn::ldivide
automaton ldivide(const automaton &lhs, const automaton &rhs)
Left-division of two automata (lhs \ rhs).
Definition: conjunction.hh:732

vcsn::dyn::focus
automaton focus(const automaton &aut, unsigned tape)
Focus on a specific tape of a tupleset automaton.
Definition: others.cc:44

vcsn::dyn::sort
automaton sort(const automaton &a)
A copy of a with normalized state numbers.
Definition: sort.hh:176

vcsn::dyn::levenshtein
automaton levenshtein(const context &ls)
The transducer representing the Levenshtein distance.
Definition: levenshtein.hh:63

vcsn::min
return exp min
Definition: multiply.hh:361

export.hh

vcsn::dyn::is_letterized
bool is_letterized(const automaton &aut)
Whether aut is letterized.
Definition: letterize.hh:201

vcsn::dyn::complement
automaton complement(const automaton &aut)
The complement of aut.
Definition: complement.hh:63

vcsn::dyn::rdivide
automaton rdivide(const automaton &lhs, const automaton &rhs)
Right-division of two automata (lhs / rhs).
Definition: conjunction.hh:767

vcsn::dyn::less_than
bool less_than(const automaton &lhs, const automaton &rhs)
Ordering between automata.
Definition: algos.hxx:40

vcsn::dyn::random_automaton
automaton random_automaton(const context &ctx, unsigned num_states, float density=0.1, unsigned num_initial=1, unsigned num_final=1, boost::optional< unsigned > max_labels={}, float loop_chance=0.0, const std::string &weights="")
A random automaton.
Definition: random-automaton.hh:217

vcsn::dyn::num_tapes
std::size_t num_tapes(const context &ctx)
The number of input tapes.
Definition: make-context.hh:166

vcsn::dyn::transposition
expression transposition(const expression &r)
Add the transposition operator to r.

vcsn::dyn::standard
automaton standard(const automaton &a)
A standardized a.
Definition: standard.hh:139

vcsn::dyn::letterize
automaton letterize(const automaton &aut)
The automaton with letter transitions instead of words.
Definition: letterize.hh:146

vcsn::dyn::push_weights
automaton push_weights(const automaton &aut)
The weight pushing automaton of aut.
Definition: push-weights.hh:71

vcsn::dyn::make_context
context make_context(const std::string &name)
Build a context from its name.
Definition: others.cc:97

vcsn::dyn::info
std::ostream & info(const automaton &aut, std::ostream &out=std::cout, unsigned details=2)
Output various facts about an automaton.
Definition: info.hh:136

vcsn::dyn::join
context join(const context &lhs, const context &rhs)
The join between two contexts, i.e., their lowest common supertype.
Definition: make-context.hh:110

vcsn::dyn::expression
value_impl< detail::expression_tag > expression
Definition: fwd.hh:31

vcsn::dyn::shuffle
automaton shuffle(const automaton &lhs, const automaton &rhs)
The shuffle product of automata lhs and rhs.
Definition: others.cc:164

vcsn::dyn::realtime
automaton realtime(const automaton &aut)
Create the realtime automaton (letterized and proper).
Definition: letterize.hh:231

vcsn::dyn::is_eps_acyclic
bool is_eps_acyclic(const automaton &aut)
Whether has no cycle of spontaneous transitions.
Definition: is-acyclic.hh:143

vcsn::dyn::cerny
automaton cerny(const context &ctx, unsigned num_states)
Produce a Černý automaton of num_states states.
Definition: cerny.hh:64

vcsn::dyn::configuration
std::string configuration(const std::string &key)
Access a configuration value.
Definition: algos.hxx:25

vcsn::dyn::weight_zero
weight weight_zero(const context &c)
The weight zero.
Definition: constant.hh:42

vcsn::dyn::component
automaton component(const automaton &aut, unsigned num)
The automaton of a strongly connected component.
Definition: scc.hh:771

vcsn::dyn::print
std::ostream & print(const automaton &aut, std::ostream &out=std::cout, const std::string &format="default")
Print automaton a on out using format format.
Definition: print.hh:121

vcsn::direction::backward
Looking upstream.

vcsn::dyn::evaluate
weight evaluate(const automaton &aut, const word &l)
Evaluate l on aut.
Definition: evaluate.hh:212

vcsn::dyn::split
polynomial split(const expression &exp)
Break exp.

vcsn::dyn::are_equal
bool are_equal(const automaton &lhs, const automaton &rhs)
Whether are the same automaton.
Definition: algos.hxx:13

vcsn::dyn::synchronize
automaton synchronize(const automaton &aut)
Create a synchronized transducer from aut.
Definition: synchronize.hh:362

vcsn::dyn::derived_term
automaton derived_term(const expression &exp, const std::string &algo="auto")
The derived-term automaton of exp.

vcsn::dyn::lightest_automaton
automaton lightest_automaton(const automaton &aut, unsigned num=1, const std::string &algo="auto")
The shortest path automaton using the given algorithm.
Definition: lightest-automaton.hh:54

vcsn::dyn::determinize
automaton determinize(const automaton &aut, const std::string &algo="auto")
The determinized automaton.
Definition: determinize.hh:357

vcsn::dyn::reduce
automaton reduce(const automaton &aut)
Reduce aut.
Definition: reduce.hh:621

vcsn::dyn::synchronizing_word
word synchronizing_word(const automaton &aut, const std::string &algo="greedy")
A synchronizing word, or raise if there is none.
Definition: synchronizing-word.hh:442

vcsn::dyn::insplit
automaton insplit(const automaton &aut, bool lazy=false)
Split automaton on the incoming transition.
Definition: insplit.hh:284

vcsn::dyn::is_functional
bool is_functional(const automaton &aut)
Whether aut is functional.
Definition: is-functional.hh:31

vcsn::dyn::random_weight
weight random_weight(const context &ctx, const std::string &param)
A random weight.
Definition: random-weight.hh:31

vcsn::dyn::transpose
automaton transpose(automaton &aut)
Transpose aut.
Definition: transpose.hh:273

vcsn::r
weightset_mixin< detail::r_impl > r
Definition: fwd.hh:54

vcsn::dyn::is_coaccessible
bool is_coaccessible(const automaton &aut)
Whether aut is coaccessible.
Definition: accessible.hh:242

vcsn::letter_class_t
std::set< std::pair< std::string, std::string > > letter_class_t
A set of letter ranges.
Definition: fwd.hh:111

vcsn::dyn::weight_one
weight weight_one(const context &c)
The weight one.
Definition: constant.hh:33

vcsn::dyn::is_normalized
bool is_normalized(const automaton &aut)
Whether is normalized (in the Thompson sense), i.e., standard and co-standard.
Definition: normalize.hh:33

vcsn::dyn::expression_one
expression expression_one(const context &c, identities ids)
The expression for \\e.
Definition: constant.hh:15

vcsn::dyn::format
std::string format(const Value &v, const std::string &format="default")
Definition: algos.hxx:31

vcsn::dyn::weight
value_impl< detail::weight_tag > weight
Definition: fwd.hh:34

vcsn::dyn::compose
automaton compose(const automaton &lhs, const automaton &rhs, bool lazy=false)
The composition of transducers lhs and rhs.
Definition: compose.hh:495

vcsn::dyn::context_of
context context_of(const automaton &a)
The context of this automaton.
Definition: make-context.hh:63

vcsn::detail::out
auto out(const Aut &aut, state_t_of< Aut > s)
Indexes of visible transitions leaving state s.
Definition: automaton.hh:86

vcsn::dyn::copy
automaton copy(const automaton &aut)
A copy of aut.
Definition: copy.hh:435

vcsn::dyn::location
vcsn::rat::location location
Pairs of positions in a file/stream.
Definition: fwd.hh:36

vcsn::dyn::partial_identity
automaton partial_identity(const automaton &aut)
Create a partial identity transducer from aut.
Definition: partial-identity.hh:81

vcsn::dyn::are_equivalent
bool are_equivalent(const automaton &lhs, const automaton &rhs)
Whether compute the same series.
Definition: are-equivalent.hh:66

vcsn::rat::ids
static identities ids(const driver &d)
Get the identities of the driver.
Definition: parse.cc:89

vcsn::dyn::direction
::vcsn::direction direction
Direction for proper on automata.
Definition: types.hh:13

vcsn::dyn::weight_series
weight weight_series(const automaton &aut)
Compute weight of the series.
Definition: weight-series.hh:55

vcsn::dyn::is_realtime
bool is_realtime(const automaton &aut)
Whether has no spontaneous transition, and is letterized.
Definition: letterize.hh:259

vcsn::dyn::star_height
unsigned star_height(const expression &rs)
Star height of an expression.

vcsn::dyn::to_automaton
automaton to_automaton(const expression &exp, const std::string &algo="auto")
An automaton denoting the language of exp.
Definition: others.cc:176

vcsn::dyn::set_format
void set_format(std::ostream &out, const std::string &format)
Specify the output format for out.
Definition: print.cc:164

vcsn::dyn::make_word_context
context make_word_context(const context &ctx)
The context for words.
Definition: make-context.hh:130

vcsn::dyn::ambiguous_word
word ambiguous_word(const automaton &aut)
An ambiguous word, or raise if there is none.
Definition: is-ambiguous.hh:124

vcsn::dyn::conjugate
automaton conjugate(const automaton &aut)
The conjugate of aut.
Definition: conjugate.hh:59

vcsn::dyn::tuple
automaton tuple(const automaton &lhs, const automaton &rhs)
Build a two-tape automaton from two automata.
Definition: others.cc:219

vcsn::dyn::lightest
polynomial lightest(const automaton &aut, unsigned num=1, const std::string &algo="auto")
The approximated behavior of an automaton with smallest weights.
Definition: lightest.hh:240

vcsn::dyn::polynomial
value_impl< detail::polynomial_tag > polynomial
Definition: fwd.hh:33

vcsn::dyn::is_useless
bool is_useless(const automaton &aut)
Whether has no useful state.
Definition: accessible.hh:260

vcsn::dyn::difference
automaton difference(const automaton &lhs, const automaton &rhs)
An automaton whose behavior is that of lhs on words not accepted by rhs.
Definition: are-equivalent.hh:140

vcsn::dyn::identities_of
identities identities_of(const expression &exp)
The identities of expression exp.

vcsn::dyn::accessible
automaton accessible(const automaton &aut)
The accessible subautomaton of aut.
Definition: accessible.hh:206

vcsn::dyn::is_codeterministic
bool is_codeterministic(const automaton &aut)
Whether aut is codeterministic.
Definition: is-deterministic.hh:98

vcsn::dyn::quotkbaseb
automaton quotkbaseb(const context &ctx, unsigned divisor, unsigned base)
A transducer that computes the quotient of the division of a word n by k in base b iff k|n...
Definition: quotkbaseb.hh:76

vcsn::dyn::has_lightening_cycle
bool has_lightening_cycle(const automaton &aut)
Whether the automaton has a cycle with lightening weight.
Definition: has-lightening-cycle.hh:35

vcsn::dyn::compare
int compare(const automaton &lhs, const automaton &rhs)
Three-way comparison between automata.
Definition: compare-automaton.hh:59

vcsn::dyn::conjunction
automaton conjunction(const automaton &lhs, const automaton &rhs, bool lazy=false)
The conjunction (aka synchronized product) of automata.
Definition: others.cc:24

vcsn::dyn::rweight
automaton rweight(const automaton &aut, const weight &w, const std::string &algo="auto")
The right-mult automaton with w as weight.
Definition: weight.hh:351

vcsn::detail::ctx
return ctx
Definition: project-context.hh:41

vcsn::dyn::random_expression
expression random_expression(const context &ctx, const std::string &param="+, ., *=.2, w., .w, length=10", identities ids={})
A random expression.
Definition: random-expression.hh:284

vcsn::dyn::constant_term
weight constant_term(const expression &e)
The weight associated to the empty word in e.

vcsn::dyn::is_trim
bool is_trim(const automaton &aut)
Whether has no useless state.
Definition: accessible.hh:251

vcsn::dyn::prefix
automaton prefix(const automaton &aut)
Create a prefix automaton from aut.
Definition: prefix.hh:84

vcsn::dyn::read_polynomial
polynomial read_polynomial(const context &ctx, std::istream &is)
Read a polynomial from a stream.
Definition: read.hh:59

vcsn::dyn::lift
automaton lift(const automaton &aut, const std::vector< unsigned > &tapes={}, identities ids={})
Lift some tapes of the transducer, or turn an automaton into a spontaneous automaton.
Definition: others.cc:69

vcsn::dyn::thompson
automaton thompson(const expression &e)
The Thompson automaton of e.

vcsn::dyn::expand
expression expand(const expression &e)
Distribute product over addition recursively under the starred subexpressions and group the equal mon...

vcsn::dyn::derivation
polynomial derivation(const expression &exp, const label &lbl, bool breaking=false)
Derive exp with respect to s.

vcsn::dyn::star_normal_form
expression star_normal_form(const expression &e)
A normalized form where star is applied only to proper expressions.

vcsn::dyn::complete
automaton complete(const automaton &aut)
A completed copy of aut.
Definition: complete.hh:80

types.hh

vcsn::dyn::lgcd
polynomial lgcd(const polynomial &lhs, const polynomial &rhs)
Left greatest common divisor of two polynomials (lhs \ rhs).

vcsn::dyn::is_synchronizing
bool is_synchronizing(const automaton &aut)
Whether is synchronizing.
Definition: synchronizing-word.hh:402

vcsn::dyn::make_label
label make_label(const context &ctx, const std::string &s, const std::string &format="default")
Build a label from a string.
Definition: algos.hxx:90

LIBVCSN_API
#define LIBVCSN_API
Definition: export.hh:8

vcsn::dyn::codeterminize
automaton codeterminize(const automaton &aut, const std::string &algo="auto")
The codeterminized automaton.
Definition: determinize.hh:435

vcsn::dyn::make_expression
expression make_expression(const context &ctx, const std::string &s, identities ids={}, const std::string &format="default")
Read an expression from a stream.
Definition: algos.hxx:71

vcsn::dyn::shortest
polynomial shortest(const automaton &aut, boost::optional< unsigned > num={}, boost::optional< unsigned > len={})
The approximated behavior of an automaton.
Definition: shortest.hh:322

vcsn::dyn::is_standard
bool is_standard(const automaton &aut)
Whether is standard (unique initial state, with weight one, no incoming transition).
Definition: standard.hh:54

vcsn::dyn::minimize
automaton minimize(const automaton &aut, const std::string &algo="auto")
The minimized automaton.
Definition: minimize.hh:158

vcsn::dyn::filter
automaton filter(const automaton &aut, const std::vector< unsigned > &ss)
The subautomaton based on aut, with only states in ss visible.
Definition: filter.hh:322

vcsn::dyn::factor
automaton factor(const automaton &aut)
Create a factor automaton from aut.
Definition: prefix.hh:121

algos.hxx

vcsn::dyn::is_ambiguous
bool is_ambiguous(const automaton &aut)
Whether aut is ambiguous.
Definition: is-ambiguous.hh:97

fwd.hh

vcsn::dyn::make_polynomial
polynomial make_polynomial(const context &ctx, const std::string &s)
Build a polynomial from a string.
Definition: algos.hxx:108

vcsn::dyn::double_ring
automaton double_ring(const context &ctx, unsigned n, const std::vector< unsigned > &f)
The double_ring automaton with n states and f the list of finals.
Definition: double-ring.hh:75

vcsn::dyn::type
std::string type(const automaton &a)
The implementation type of a.
Definition: others.cc:239

vcsn::dyn::expression_zero
expression expression_zero(const context &c, identities ids)
The expression for \\z.
Definition: constant.hh:24

vcsn::dyn::de_bruijn
automaton de_bruijn(const context &ctx, unsigned n)
A simple NFA for (a+b)*a(a+b)^n.
Definition: de-bruijn.hh:57

vcsn::dyn::add
automaton add(const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
Sum of two automata.
Definition: add.hh:124

vcsn::dyn::make_weight
weight make_weight(const context &ctx, const std::string &s)
Build a weight from a string.
Definition: algos.hxx:125

vcsn::dyn::is_cycle_ambiguous
bool is_cycle_ambiguous(const automaton &aut)
Whether the automaton is cycle-ambiguous.
Definition: is-ambiguous.hh:197

vcsn::dyn::pair
automaton pair(const automaton &aut, bool keep_initials=false)
Build the pair automaton of the given automaton.
Definition: pair.hh:264

vcsn::dyn::num_components
std::size_t num_components(const automaton &aut)
The number of strongly connected components.
Definition: scc.hh:735

vcsn::dyn::is_empty
bool is_empty(const automaton &aut)
Whether has no state.
Definition: accessible.hh:269

vcsn::dyn::multiply
automaton multiply(const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
Multiply (concatenate) two automata.
Definition: multiply.hh:169

vcsn::dyn::delay_automaton
automaton delay_automaton(const automaton &a)
The automaton with the delay of each state.
Definition: is-synchronized.hh:349

vcsn::dyn::is_out_sorted
bool is_out_sorted(const automaton &aut)
Whether the outgoing transitions of each state have increasing labels.
Definition: sort.hh:75

vcsn::dyn::costandard
automaton costandard(const automaton &a)
A co-standardized a.
Definition: standard.hh:148

vcsn::dyn::random_automaton_deterministic
automaton random_automaton_deterministic(const context &ctx, unsigned num_states)
A random deterministic automaton.
Definition: random-automaton.hh:276

vcsn::dyn::universal
automaton universal(const automaton &aut)
The universal automaton of aut.
Definition: universal.hh:148

vcsn::dyn::is_partial_identity
bool is_partial_identity(const automaton &aut)
Whether aut realizes a partial identity.
Definition: is-partial-identity.hh:80

vcsn::dyn::suffix
automaton suffix(const automaton &aut)
Create a suffix automaton from aut.
Definition: prefix.hh:44

vcsn::dyn::strip
automaton strip(const automaton &a)
The automaton in a with its metadata layers removed.
Definition: strip.hh:46

vcsn::dyn::are_isomorphic
bool are_isomorphic(const automaton &lhs, const automaton &rhs)
Whether there exists an isomorphism between the states of lhs and those of rhs.
Definition: are-isomorphic.hh:707

vcsn::dyn::is_deterministic
bool is_deterministic(const automaton &aut)
Whether aut is deterministic.
Definition: is-deterministic.hh:85

vcsn::dyn::make_automaton
automaton make_automaton(const std::string &data, const std::string &format="default", bool strip=true)
Read an automaton from a string.
Definition: algos.hxx:52

vcsn::dyn::trim
automaton trim(const automaton &aut)
The trim subautomaton of aut.
Definition: accessible.hh:224

vcsn::dyn::inductive
automaton inductive(const expression &e, const std::string &algo="auto")
The inductive translation of e in an automaton.

vcsn::dyn::condense
automaton condense(const automaton &aut)
The condensation of aut such that each state is a strongly connected component.
Definition: scc.hh:832

vcsn::dyn::read_weight
weight read_weight(const context &ctx, std::istream &is)
Read a weight from a stream.
Definition: read.hh:89

vcsn::dyn::is_complete
bool is_complete(const automaton &aut)
Whether aut is complete.
Definition: is-complete.hh:52

vcsn::dyn::is_synchronized
bool is_synchronized(const automaton &aut)
Whether is synchronized.
Definition: is-synchronized.hh:320

vcsn::dyn::make_automaton_editor
automaton_editor * make_automaton_editor(const context &ctx)
Build an automaton editor from its context.
Definition: edit-automaton.hh:349

vcsn::dyn::eliminate_state
automaton eliminate_state(const automaton &aut, int s=-1)
The LAO automaton aut with state s removed.
Definition: to-automaton.hh:46

vcsn::dyn::has_twins_property
bool has_twins_property(const automaton &aut)
Whether the automaton has the twins property.
Definition: has-twins-property.hh:168

vcsn::dyn::read_label
label read_label(const context &ctx, std::istream &is, const std::string &format="default")
Read a label from a stream.
Definition: read.cc:123

vcsn::dyn::read_automaton
automaton read_automaton(std::istream &is, const std::string &format="default", bool strip=true, const location &loc=location{})
Read an automaton from a stream.
Definition: read.cc:72

vcsn::dyn::has_bounded_lag
bool has_bounded_lag(const automaton &aut)
Whether the transducer has bounded lag.
Definition: has-bounded-lag.hh:162