algos.hh

Go to the documentation of this file.

#ifndef VCSN_DYN_ALGOS_HH
# define VCSN_DYN_ALGOS_HH

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

# include <vcsn/algos/fwd.hh>
# include <vcsn/core/rat/identities.hh>
# include <vcsn/ctx/fwd.hh>
# include <vcsn/dyn/fwd.hh>
# include <vcsn/misc/direction.hh>
# include <vcsn/misc/export.hh>

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

    label ambiguous_word(const automaton& aut);

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

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

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

    automaton blind(automaton& aut, unsigned tape);

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

    automaton chain(const automaton& aut, int min, int max);

    ratexp chain(const ratexp& e, int min, int max);

    automaton coaccessible(const automaton& aut);

    automaton complement(const automaton& aut);

    ratexp complement(const ratexp& r);

    automaton complete(const automaton& aut);

    automaton compose(automaton& lhs, automaton& rhs);

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

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

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

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

    weight constant_term(const ratexp& e);

    context context_of(const automaton& a);

    context context_of(const ratexp& r);

    automaton copy(const automaton& aut);

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

    ratexp copy(const ratexp& exp, const ratexpset& rs);

    automaton costandard(const automaton& a);

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

    polynomial derivation(const ratexp& exp, const label& l,
                          bool breaking = false);

    automaton derived_term(const ratexp& e,
                           const std::string& algo = "auto");

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

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

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

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

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

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

    std::ostream& dot(const automaton& aut, std::ostream& out,
                      bool dot2tex = false);

    std::string dot(const automaton& aut);

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

    automaton eliminate_state(const automaton& aut, int s);

    std::ostream& efsm(const automaton& aut, std::ostream& out);

    polynomial enumerate(const automaton& aut, unsigned max);

    weight eval(const automaton& aut, const label& l);

    ratexp expand(const ratexp& e);

    automaton factor(const automaton& aut);

    std::ostream& fado(const automaton& aut, std::ostream& out);

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

    std::ostream& grail(const automaton& aut, std::ostream& out);

    bool has_twins_property(const automaton& aut);

    rat::identities identities(const ratexp& exp);

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

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

    std::ostream& info(const automaton& aut, std::ostream& out,
                       bool detailed = false);

    std::ostream& info(const ratexp& exp, std::ostream& out);

    automaton insplit(const automaton& aut);

    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_normalized(const automaton& aut);

    bool is_out_sorted(const automaton& aut);

    bool is_proper(const automaton& aut);

    bool is_standard(const automaton& aut);

    bool is_synchronized_by(const automaton& aut, const label& 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 ratexp& e);

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

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

    automaton left_mult(const weight& w, const automaton& aut);

    ratexp left_mult(const weight& w, const ratexp& aut);

    automaton lift(const automaton& aut);

    ratexp lift(const ratexp& e);

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

    automaton_editor* make_automaton_editor(const context& ctx);

    ratexpset make_ratexpset(const context& ctx, ::vcsn::rat::identities is);

    context make_word_context(const context& ctx);

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

    automaton normalize(const automaton& aut);

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

    automaton prefix(const automaton& aut);

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

    std::ostream& print(const automaton& a, std::ostream& o,
                        const std::string& format = "default");

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

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

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

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

    std::ostream& print(const ratexp& e, std::ostream& o,
                        const std::string& format = "default");

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

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

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

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

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

    automaton proper(const automaton& aut,
                     direction dir = direction::backward,
                     bool prune = true);

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

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

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

    label read_label(std::istream& is, const context& ctx);

    ratexp read_ratexp(std::istream& is, const ratexpset& rs,
                       const std::string& format = "default");

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

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

    automaton reduce(const automaton& aut);

    automaton right_mult(const automaton& aut, const weight& w);

    ratexp right_mult(const ratexp& aut, const weight& w);

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

    polynomial shortest(const automaton& aut, unsigned max = 1);

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

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

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

    automaton sort(const automaton& a);

    polynomial split(const polynomial& p);

    polynomial split(const ratexp& exp);

    automaton standard(const automaton& a);

    automaton standard(const ratexp& e);

    automaton star(const automaton& aut);

    unsigned star_height(const ratexp& rs);

    ratexp star_normal_form(const ratexp& e);

    automaton strip(const automaton& a);

    automaton suffix(const automaton& aut);

    automaton subword(const automaton& aut);

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

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

    ratexp sum(const ratexp& lhs, const ratexp& rhs);

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

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

    automaton thompson(const ratexp& e);

    std::ostream& tikz(const automaton& aut, std::ostream& out);

    expansion to_expansion(const ratexp& exp);

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

    automaton transpose(automaton& aut);

    ratexp transpose(const ratexp& e);

    ratexp transposition(const ratexp& r);

    automaton trim(const automaton& aut);

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

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

    automaton universal(const automaton& aut);

  }
}

namespace std LIBVCSN_API
{
  std::ostream& operator<<(std::ostream& o, const vcsn::dyn::automaton& a);

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

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

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

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

  std::ostream& operator<<(std::ostream& o, const vcsn::dyn::ratexp& e);

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

#endif // !VCSN_DYN_ALGOS_HH