10 namespace vcsn {
namespace dyn {
1122 multiply(
const weight& lhs,
const weight& rhs)
1248 random_automaton(
const context&
ctx,
unsigned num_states,
float density,
unsigned num_initial,
unsigned num_final, boost::optional<unsigned> max_labels,
float loop_chance,
const std::string& weights)
1311 rdivide(
const weight& lhs,
const weight& rhs)
1671 tuple(
const std::vector<expression>& es)
1680 tuple(
const std::vector<polynomial>& ps)
weight evaluate(const automaton &aut, const word &l)
Evaluate l on aut.
polynomial split(const expression &exp)
Break exp.
static Registry< ldivide_label_t > & ldivide_label_registry()
static Registry< concatenate_expression_t > & concatenate_expression_registry()
static Registry< is_costandard_t > & is_costandard_registry()
automaton derived_term(const expression &exp, const std::string &algo="auto")
The derived-term automaton of exp.
automaton lightest_automaton(const automaton &aut, unsigned num=1, const std::string &algo="auto")
The shortest path automaton using the given algorithm.
automaton prefix(const automaton &aut)
Create a prefix automaton from aut.
automaton determinize(const automaton &aut, const std::string &algo="auto")
The determinized automaton.
label multiply_label(const label &lhs, const label &rhs)
Bridge (multiply).
Abstract Builder (the design pattern) for automata.
std::set< std::pair< std::string, std::string >> letter_class_t
A set of letter ranges.
static Registry< subword_t > & subword_registry()
polynomial read_polynomial(const context &ctx, std::istream &is)
Read a polynomial from a stream.
bool is_functional(const automaton &aut)
Whether aut is functional.
weight random_weight(const context &ctx, const std::string ¶m)
A random weight.
automaton transpose(automaton &aut)
Transpose aut.
static Registry< multiply_expression_t > & multiply_expression_registry()
static Registry< rdivide_label_t > & rdivide_label_registry()
bool is_coaccessible(const automaton &aut)
Whether aut is coaccessible.
automaton_editor * make_automaton_editor(const context &ctx)
Build an automatonset from its context.
static Registry< multiply_expression_repeated_t > & multiply_expression_repeated_registry()
expression transpose_expression(const expression &exp)
Bridge (transpose).
static Registry< num_tapes_t > & num_tapes_registry()
static Registry< compose_expansion_t > & compose_expansion_registry()
static Registry< is_trim_t > & is_trim_registry()
expression expression_one(const context &c, identities ids)
The expression for \\e.
expression expand(const expression &e)
Distribute product over addition recursively under the starred subexpressions and group the equal mon...
polynomial derivation(const expression &exp, const label &lbl, bool breaking=false)
Derive exp with respect to s.
label ldivide_label(const label &lhs, const label &rhs)
Bridge (ldivide).
std::size_t num_tapes(const context &ctx)
The number of input tapes.
expression concatenate_expression(const expression &lhs, const expression &rhs)
Bridge (concatenate).
static Registry< standard_expression_t > & standard_expression_registry()
static Registry< synchronizing_word_t > & synchronizing_word_registry()
static Registry< cotrie_t > & cotrie_registry()
automaton compose(const automaton &lhs, const automaton &rhs, bool lazy=false)
The composition of transducers lhs and rhs.
context context_of(const automaton &a)
The context of this automaton.
expression shuffle_expression(const expression &lhs, const expression &rhs)
Bridge (shuffle).
static Registry< complement_expression_t > & complement_expression_registry()
auto out(const Aut &aut, state_t_of< Aut > s)
Indexes of visible transitions leaving state s.
static Registry< transpose_expression_t > & transpose_expression_registry()
static Registry< is_coaccessible_t > & is_coaccessible_registry()
static Registry< multiply_weight_t > & multiply_weight_registry()
automaton partial_identity(const automaton &aut)
Create a partial identity transducer from aut.
expression difference_expression(const expression &lhs, const expression &rhs)
Bridge (difference).
static Registry< complement_t > & complement_registry()
static Registry< has_twins_property_t > & has_twins_property_registry()
static Registry< sort_t > & sort_registry()
expansion conjunction_expansion(const expansion &lhs, const expansion &rhs)
Bridge (conjunction).
static Registry< shuffle_t > & shuffle_registry()
static Registry< is_realtime_t > & is_realtime_registry()
static Registry< is_synchronizing_t > & is_synchronizing_registry()
bool is_standard(const automaton &aut)
Whether is standard (unique initial state, with weight one, no incoming transition).
static Registry< difference_expression_t > & difference_expression_registry()
expression compose_expression(const expression &lhs, const expression &rhs)
Bridge (compose).
unsigned star_height(const expression &rs)
Star height of an expression.
static Registry< insplit_t > & insplit_registry()
static Registry< is_complete_t > & is_complete_registry()
context make_word_context(const context &ctx)
The context for words.
automaton conjugate(const automaton &aut)
The conjugate of aut.
static Registry< letterize_t > & letterize_registry()
automaton factor(const automaton &aut)
Create a factor automaton from aut.
static Registry< constant_term_t > & constant_term_registry()
expansion compose_expansion(const expansion &lhs, const expansion &rhs)
Bridge (compose).
static Registry< weight_zero_t > & weight_zero_registry()
bool is_ambiguous(const automaton &aut)
Whether aut is ambiguous.
static Registry< info_expression_t > & info_expression_registry()
automaton tuple(const automaton &lhs, const automaton &rhs)
Build a two-tape automaton from two automata.
static Registry< random_automaton_t > & random_automaton_registry()
static Registry< is_standard_t > & is_standard_registry()
polynomial rweight_polynomial(const polynomial &poly, const weight &weight)
Bridge (rweight).
polynomial lightest(const automaton &aut, unsigned num=1, const std::string &algo="auto")
The approximated behavior of an automaton with smallest weights.
static Registry< is_valid_t > & is_valid_registry()
static Registry< add_t > & add_registry()
auto tuple_context(Ctx &&...ctx) -> context< tupleset< labelset_t_of< Ctx >...>, join_t< weightset_t_of< Ctx >...>>
std::ostream & print_context(const context &ctx, std::ostream &o, const std::string &fmt)
Bridge (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.
bool is_useless(const automaton &aut)
Whether has no useful state.
static Registry< is_empty_t > & is_empty_registry()
weight rdivide_weight(const weight &lhs, const weight &rhs)
Bridge (rdivide).
std::size_t num_components(const automaton &aut)
The number of strongly connected components.
static Registry< conjunction_polynomial_t > & conjunction_polynomial_registry()
bool is_empty(const automaton &aut)
Whether has no state.
static Registry< scc_t > & scc_registry()
automaton delay_automaton(const automaton &a)
The automaton with the delay of each state.
static Registry< lweight_t > & lweight_registry()
word ambiguous_word(const automaton &aut)
An ambiguous word, or raise if there is none.
static Registry< strip_t > & strip_registry()
static Registry< lweight_polynomial_t > & lweight_polynomial_registry()
static Registry< info_t > & info_registry()
automaton accessible(const automaton &aut)
The accessible subautomaton of aut.
static Registry< thompson_t > & thompson_registry()
static Registry< expand_t > & expand_registry()
automaton random_automaton_deterministic(const context &ctx, unsigned num_states)
A random deterministic automaton.
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...
static Registry< factor_t > & factor_registry()
bool has_lightening_cycle(const automaton &aut)
Whether the automaton has a cycle with lightening weight.
automaton universal(const automaton &aut)
The universal automaton of aut.
static Registry< quotkbaseb_t > & quotkbaseb_registry()
static Registry< lift_expression_t > & lift_expression_registry()
An input/output format for valuesets.
bool is_partial_identity(const automaton &aut)
Whether aut realizes a partial identity.
automaton conjunction(const automaton &lhs, const automaton &rhs, bool lazy=false)
The conjunction (aka synchronized product) of automata.
static Registry< cerny_t > & cerny_registry()
bool are_isomorphic(const automaton &lhs, const automaton &rhs)
Whether there exists an isomorphism between the states of lhs and those of rhs.
static Registry< conjunction_expansion_t > & conjunction_expansion_registry()
static Registry< star_height_t > & star_height_registry()
static Registry< copy_convert_t > & copy_convert_registry()
static Registry< rdivide_weight_t > & rdivide_weight_registry()
static Registry< transposition_expression_t > & transposition_expression_registry()
weight ldivide_weight(const weight &lhs, const weight &rhs)
Bridge (ldivide).
automaton rweight(const automaton &aut, const weight &w, const std::string &algo="auto")
The right-mult automaton with w as weight.
expression random_expression(const context &ctx, const std::string ¶m="+, ., *=.2, w., .w, length=10", identities ids={})
A random expression.
automaton trim(const automaton &aut)
The trim subautomaton of aut.
weight constant_term(const expression &e)
The weight associated to the empty word in e.
bool is_trim(const automaton &aut)
Whether has no useless state.
automaton inductive(const expression &e, const std::string &algo="auto")
The inductive translation of e in an automaton.
automaton condense(const automaton &aut)
The condensation of aut such that each state is a strongly connected component.
static Registry< read_weight_t > & read_weight_registry()
static Registry< synchronize_t > & synchronize_registry()
static Registry< multiply_t > & multiply_registry()
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.
static Registry< is_useless_t > & is_useless_registry()
static Registry< trie_t > & trie_registry()
automaton conjunction_repeated(const automaton &aut, unsigned n)
Bridge (conjunction).
expression ldivide_expression(const expression &lhs, const expression &rhs)
Bridge (ldivide).
static Registry< are_equivalent_expression_t > & are_equivalent_expression_registry()
static Registry< rweight_expression_t > & rweight_expression_registry()
static Registry< tuple_t > & tuple_registry()
static Registry< compose_expression_t > & compose_expression_registry()
static Registry< standard_t > & standard_registry()
bool has_twins_property(const automaton &aut)
Whether the automaton has the twins property.
static Registry< to_expression_class_t > & to_expression_class_registry()
automaton thompson(const expression &e)
The Thompson automaton of e.
static Registry< divkbaseb_t > & divkbaseb_registry()
static Registry< is_normalized_t > & is_normalized_registry()
expression star_normal_form(const expression &e)
A normalized form where star is applied only to proper expressions.
static Registry< is_accessible_t > & is_accessible_registry()
automaton complete(const automaton &aut)
A completed copy of aut.
expression infiltrate_expression(const expression &lhs, const expression &rhs)
Bridge (infiltrate).
static Registry< prefix_t > & prefix_registry()
expansion complement_expansion(const expansion &xpn)
Bridge (complement).
static Registry< complement_expansion_t > & complement_expansion_registry()
polynomial lgcd(const polynomial &lhs, const polynomial &rhs)
Left greatest common divisor of two polynomials (lhs \ rhs).
automaton zpc(const expression &exp, const std::string &algo="auto")
The ZPC automaton of exp.
bool is_synchronizing(const automaton &aut)
Whether is synchronizing.
automaton infiltrate(const automaton &lhs, const automaton &rhs)
The infiltration of automata lhs and rhs.
static Registry< coaccessible_t > & coaccessible_registry()
automaton codeterminize(const automaton &aut, const std::string &algo="auto")
The codeterminized automaton.
context context_of_expansion(const expansion &exp)
Bridge (context_of).
static Registry< ldivide_polynomial_t > & ldivide_polynomial_registry()
static Registry< transpose_t > & transpose_registry()
automaton coaccessible(const automaton &aut)
The coaccessible subautomaton of aut.
static Registry< star_normal_form_t > & star_normal_form_registry()
polynomial shortest(const automaton &aut, boost::optional< unsigned > num={}, boost::optional< unsigned > len={})
The approximated behavior of an automaton.
static Registry< compose_t > & compose_registry()
static Registry< de_bruijn_t > & de_bruijn_registry()
bool is_synchronized_by(const automaton &aut, const word &word)
Whether the word synchronizes aut.
static Registry< lweight_expansion_t > & lweight_expansion_registry()
static Registry< are_isomorphic_t > & are_isomorphic_registry()
automaton trie_stream(const context &ctx, std::istream &is, const std::string &format)
Bridge (trie).
expression complement_expression(const expression &exp)
Bridge (complement).
static Registry< universal_t > & universal_registry()
automaton subword(const automaton &aut)
Create a subword automaton from aut.
expansion to_expansion(const expression &exp)
First order development of a exp.
static Registry< tuple_context_t > & tuple_context_registry()
polynomial multiply_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (multiply).
static Registry< conjunction_repeated_t > & conjunction_repeated_registry()
automaton minimize(const automaton &aut, const std::string &algo="auto")
The minimized automaton.
automaton filter(const automaton &aut, const std::vector< unsigned > &ss)
The subautomaton based on aut, with only states in ss visible.
static Registry< cotrie_stream_t > & cotrie_stream_registry()
static Registry< compose_polynomial_t > & compose_polynomial_registry()
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.
static Registry< shortest_t > & shortest_registry()
expression copy_expression(const expression &exp, const context &ctx, identities ids)
Bridge (copy).
static Registry< lweight_expression_t > & lweight_expression_registry()
bool is_accessible(const automaton &aut)
Whether aut is accessible.
static Registry< partial_identity_expression_t > & partial_identity_expression_registry()
expression expression_zero(const context &c, identities ids)
The expression for \\z.
label multiply_label_repeated(const label &re, int exp)
Bridge (multiply).
static Registry< random_expression_t > & random_expression_registry()
static Registry< tuple_polynomial_t > & tuple_polynomial_registry()
expression concatenate(const expression &lhs, const expression &rhs)
Concatenate two expressions.
automaton de_bruijn(const context &ctx, unsigned n)
A simple NFA for (a+b)*a(a+b)^n.
automaton add(const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
Sum of two automata.
word synchronizing_word(const automaton &aut, const std::string &algo="greedy")
A synchronizing word, or raise if there is none.
static Registry< print_context_t > & print_context_registry()
bool is_cycle_ambiguous(const automaton &aut)
Whether the automaton is cycle-ambiguous.
automaton pair(const automaton &aut, bool keep_initials=false)
Build the pair automaton of the given automaton.
static Registry< ldivide_weight_t > & ldivide_weight_registry()
expansion lweight_expansion(const weight &weight, const expansion &exp)
Bridge (lweight).
automaton multiply(const automaton &lhs, const automaton &rhs, const std::string &algo="auto")
Multiply (concatenate) two automata.
static Registry< expression_one_t > & expression_one_registry()
automaton cominimize(const automaton &aut, const std::string &algo="auto")
The cominimized automaton.
static Registry< is_functional_t > & is_functional_registry()
static Registry< conjunction_expression_t > & conjunction_expression_registry()
bool is_valid(const automaton &e)
Whether automaton is valid (epsilon-cycles converge).
static Registry< is_out_sorted_t > & is_out_sorted_registry()
static Registry< derived_term_t > & derived_term_registry()
static Registry< context_of_polynomial_t > & context_of_polynomial_registry()
bool is_out_sorted(const automaton &aut)
Whether the outgoing transitions of each state have increasing labels.
Template-less root for contexts.
automaton costandard(const automaton &a)
A co-standardized a.
static Registry< is_cycle_ambiguous_t > & is_cycle_ambiguous_registry()
expression multiply_expression_repeated(const expression &re, int min, int max)
Bridge (multiply).
static Registry< partial_identity_t > & partial_identity_registry()
static Registry< lgcd_polynomial_t > & lgcd_polynomial_registry()
automaton ldivide(const automaton &lhs, const automaton &rhs)
Left-division of two automata (lhs \ rhs).
polynomial tuple_polynomial(const std::vector< polynomial > &ps)
Bridge (tuple).
expression lift_expression(const expression &exp)
Bridge (lift).
static Registry< rdivide_expression_t > & rdivide_expression_registry()
automaton sort(const automaton &a)
A copy of a with normalized state numbers.
expression to_expression_label(const context &ctx, identities ids, const label &lbl)
Bridge (to_expression).
static Registry< delay_automaton_t > & delay_automaton_registry()
static Registry< pair_t > & pair_registry()
static Registry< make_word_context_t > & make_word_context_registry()
automaton suffix(const automaton &aut)
Create a suffix automaton from aut.
automaton strip(const automaton &a)
The automaton in a with its metadata layers removed.
bool is_deterministic(const automaton &aut)
Whether aut is deterministic.
static Registry< copy_t > & copy_registry()
static Registry< is_valid_expression_t > & is_valid_expression_registry()
static Registry< to_expansion_t > & to_expansion_registry()
expression partial_identity_expression(const expression &exp)
Bridge (partial_identity).
expression rweight_expression(const expression &exp, const weight &weight)
Bridge (rweight).
automaton multiply_repeated(const automaton &a, int min, int max, const std::string &algo)
Bridge (multiply).
context context_of_expression(const expression &exp)
Bridge (context_of).
automaton standard_expression(const expression &exp)
Bridge (standard).
bool is_letterized(const automaton &aut)
Whether aut is letterized.
automaton complement(const automaton &aut)
The complement of aut.
static Registry< ambiguous_word_t > & ambiguous_word_registry()
std::ostream & info_expression(const expression &exp, std::ostream &o)
Bridge (info).
bool are_equivalent_expression(const expression &r1, const expression &r2)
Bridge (are_equivalent).
weight read_weight(const context &ctx, std::istream &is)
Read a weight from a stream.
static Registry< infiltrate_t > & infiltrate_registry()
static Registry< codeterminize_t > & codeterminize_registry()
static Registry< cominimize_t > & cominimize_registry()
static Registry< is_partial_identity_t > & is_partial_identity_registry()
expression lweight_expression(const weight &weight, const expression &exp)
Bridge (lweight).
static Registry< add_expression_t > & add_expression_registry()
static Registry< infiltrate_expression_t > & infiltrate_expression_registry()
static Registry< suffix_t > & suffix_registry()
context context_of_polynomial(const polynomial &poly)
Bridge (context_of).
bool is_complete(const automaton &aut)
Whether aut is complete.
static Registry< trim_t > & trim_registry()
bool is_synchronized(const automaton &aut)
Whether is synchronized.
static Registry< realtime_t > & realtime_registry()
static Registry< make_automaton_editor_t > & make_automaton_editor_registry()
static Registry< double_ring_t > & double_ring_registry()
static Registry< conjugate_t > & conjugate_registry()
bool less_than(const expression &lhs, const expression &rhs)
Ordering between expressions.
polynomial lgcd_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (lgcd).
static Registry< proper_t > & proper_registry()
automaton eliminate_state(const automaton &aut, int s=-1)
The LAO automaton aut with state s removed.
weight add_weight(const weight &lhs, const weight &rhs)
Bridge (add).
expression multiply_expression(const expression &lhs, const expression &rhs)
Bridge (multiply).
expansion tuple_expansion(const std::vector< expansion > &es)
Bridge (tuple).
polynomial compose_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (compose).
static Registry< is_deterministic_t > & is_deterministic_registry()
static Registry< levenshtein_t > & levenshtein_registry()
automaton standard(const automaton &a)
A standardized a.
static Registry< multiply_polynomial_t > & multiply_polynomial_registry()
expansion rweight_expansion(const expansion &exp, const weight &weight)
Bridge (rweight).
static Registry< has_lightening_cycle_t > & has_lightening_cycle_registry()
static Registry< expression_zero_t > & expression_zero_registry()
bool has_bounded_lag(const automaton &aut)
Whether the transducer has bounded lag.
automaton ladybird(const context &ctx, unsigned n)
The ladybird automaton with n states.
expression to_expression(const automaton &aut, identities ids={}, const std::string &algo="auto")
An expression denoting the language of aut.
bool is_valid_expression(const expression &exp)
Bridge (is_valid).
PolynomialSet::value_t split_polynomial(const PolynomialSet &ps, const typename PolynomialSet::value_t &p)
Split a polynomial of expressions, given the polynomialset.
static Registry< ldivide_expansion_t > & ldivide_expansion_registry()
static Registry< difference_t > & difference_registry()
weight multiply_weight_repeated(const weight &wgt, int min, int max)
Bridge (multiply).
weight multiply_weight(const weight &lhs, const weight &rhs)
Bridge (multiply).
static Registry< complete_t > & complete_registry()
static Registry< is_synchronized_by_t > & is_synchronized_by_registry()
std::ostream & info(const automaton &aut, std::ostream &out=std::cout, unsigned details=2)
Output various facts about an automaton.
automaton star(const automaton &aut, const std::string &algo="auto")
Star of an automaton.
expression transposition_expression(const expression &exp)
Bridge (transposition).
automaton u(const context &ctx, unsigned n)
The Brzozowski universal witness.
static Registry< is_eps_acyclic_t > & is_eps_acyclic_registry()
static Registry< split_polynomial_t > & split_polynomial_registry()
static Registry< rweight_polynomial_t > & rweight_polynomial_registry()
automaton shuffle(const automaton &lhs, const automaton &rhs)
The shuffle product of automata lhs and rhs.
static Registry< eliminate_state_t > & eliminate_state_registry()
automaton copy_convert(const automaton &aut, const context &ctx)
Bridge (copy).
static Registry< are_equivalent_t > & are_equivalent_registry()
automaton realtime(const automaton &aut)
Create the realtime automaton (letterized and proper).
static Registry< costandard_t > & costandard_registry()
static Registry< read_polynomial_t > & read_polynomial_registry()
static Registry< random_automaton_deterministic_t > & random_automaton_deterministic_registry()
automaton component(const automaton &aut, unsigned num)
The automaton of a strongly connected component.
static Registry< to_expression_t > & to_expression_registry()
static Registry< num_components_t > & num_components_registry()
expression rdivide_expression(const expression &lhs, const expression &rhs)
Bridge (rdivide).
static Registry< join_t > & join_registry()
static Registry< reduce_t > & reduce_registry()
std::shared_ptr< detail::delay_automaton_impl< Aut >> delay_automaton
An automaton wrapper that presents the delay automaton.
automaton trie(const polynomial &p)
A trie-like automaton (single initial state, multiple final states) to accept p.
bool is_proper(const automaton &aut)
Whether has no spontaneous transition.
automaton lweight(const weight &w, const automaton &aut, const std::string &algo="auto")
The left-multiplication of an automaton with w as weight.
static Registry< derivation_t > & derivation_registry()
automaton synchronize(const automaton &aut)
Create a synchronized transducer from aut.
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...
static Registry< normalize_t > & normalize_registry()
static Registry< add_expansion_t > & add_expansion_registry()
static identities ids(const driver &d)
Get the identities of the driver.
bool is_costandard(const automaton &aut)
Whether is costandard (unique final state, with weight one, no outcoming transition).
automaton reduce(const automaton &aut)
Reduce aut.
automaton insplit(const automaton &aut, bool lazy=false)
Split automaton on the incoming transition.
expansion ldivide_expansion(const expansion &lhs, const expansion &rhs)
Bridge (ldivide).
polynomial add_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (add).
static Registry< rweight_expansion_t > & rweight_expansion_registry()
static Registry< context_of_expansion_t > & context_of_expansion_registry()
automaton cotrie(const polynomial &p)
A reversed trie-like automaton (multiple initial states, single final state) automaton to accept p...
static Registry< tuple_expression_t > & tuple_expression_registry()
automaton normalize(const automaton &aut)
Normalize automaton aut.
static Registry< lightest_t > & lightest_registry()
automaton proper(const automaton &aut, direction dir=direction::backward, bool prune=true, const std::string &algo="auto")
An equivalent automaton without spontaneous transitions.
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.
static Registry< add_polynomial_t > & add_polynomial_registry()
static Registry< multiply_label_repeated_t > & multiply_label_repeated_registry()
static Registry< is_codeterministic_t > & is_codeterministic_registry()
static Registry< to_expression_label_t > & to_expression_label_registry()
static Registry< context_of_t > & context_of_registry()
weight weight_one(const context &c)
The weight one.
static Registry< context_of_expression_t > & context_of_expression_registry()
bool is_normalized(const automaton &aut)
Whether is normalized (in the Thompson sense), i.e., standard and co-standard.
static Registry< shuffle_expression_t > & shuffle_expression_registry()
static Registry< minimize_t > & minimize_registry()
static Registry< zpc_t > & zpc_registry()
static Registry< component_t > & component_registry()
automaton levenshtein(const context &ls)
The transducer representing the Levenshtein distance.
automaton cotrie_stream(const context &ctx, std::istream &is, const std::string &format)
Bridge (cotrie).
static Registry< copy_expression_t > & copy_expression_registry()
expression conjunction_expression(const expression &lhs, const expression &rhs)
Bridge (conjunction).
automaton copy(const automaton &aut)
A copy of aut.
static Registry< ldivide_t > & ldivide_registry()
label rdivide_label(const label &lhs, const label &rhs)
Bridge (rdivide).
polynomial conjunction_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (conjunction).
static Registry< push_weights_t > & push_weights_registry()
bool less_than_expression(const expression &lhs, const expression &rhs)
Bridge (less_than).
static Registry< inductive_t > & inductive_registry()
static Registry< weight_one_t > & weight_one_registry()
bool are_equivalent(const automaton &lhs, const automaton &rhs)
Whether compute the same series.
static Registry< rdivide_t > & rdivide_registry()
automaton rdivide(const automaton &lhs, const automaton &rhs)
Right-division of two automata (lhs / rhs).
weight weight_series(const automaton &aut)
Compute weight of the series.
polynomial lweight_polynomial(const weight &weight, const polynomial &poly)
Bridge (lweight).
bool is_realtime(const automaton &aut)
Whether has no spontaneous transition, and is letterized.
static Registry< ldivide_expression_t > & ldivide_expression_registry()
static Registry< add_weight_t > & add_weight_registry()
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.
static Registry< trie_stream_t > & trie_stream_registry()
static Registry< accessible_t > & accessible_registry()
static Registry< u_t > & u_registry()
expression to_expression_class(const context &ctx, identities ids, const letter_class_t &letters, bool accept)
Bridge (to_expression).
static Registry< random_weight_t > & random_weight_registry()
expression transposition(const expression &r)
Add the transposition operator to r.
static Registry< evaluate_t > & evaluate_registry()
static Registry< is_synchronized_t > & is_synchronized_registry()
automaton letterize(const automaton &aut)
The automaton with letter transitions instead of words.
static Registry< ladybird_t > & ladybird_registry()
automaton push_weights(const automaton &aut)
The weight pushing automaton of aut.
static Registry< lightest_automaton_t > & lightest_automaton_registry()
static Registry< less_than_expression_t > & less_than_expression_registry()
static Registry< is_proper_t > & is_proper_registry()
context join(const context &lhs, const context &rhs)
The join between two contexts, i.e., their lowest common supertype.
automaton difference(const automaton &lhs, const automaton &rhs)
An automaton whose behavior is that of lhs on words not accepted by rhs.
static Registry< eval_polynomial_t > & eval_polynomial_registry()
static Registry< split_t > & split_registry()
identities identities_of(const expression &exp)
The identities of expression exp.
value_impl< detail::expression_tag > expression
expression tuple_expression(const std::vector< expression > &es)
Bridge (tuple).
static Registry< has_bounded_lag_t > & has_bounded_lag_registry()
weight eval_polynomial(const automaton &aut, const polynomial &poly)
Bridge (evaluate).
static Registry< conjunction_t > & conjunction_registry()
static Registry< filter_t > & filter_registry()
static Registry< identities_of_t > & identities_of_registry()
static Registry< condense_t > & condense_registry()
expansion add_expansion(const expansion &lhs, const expansion &rhs)
Bridge (add).
static Registry< is_letterized_t > & is_letterized_registry()
bool is_codeterministic(const automaton &aut)
Whether aut is codeterministic.
expression add_expression(const expression &lhs, const expression &rhs)
Bridge (add).
static Registry< star_t > & star_registry()
static Registry< print_t > & print_registry()
static Registry< is_ambiguous_t > & is_ambiguous_registry()
static Registry< determinize_t > & determinize_registry()
static Registry< multiply_weight_repeated_t > & multiply_weight_repeated_registry()
static Registry< rweight_t > & rweight_registry()
bool is_eps_acyclic(const automaton &aut)
Whether has no cycle of spontaneous transitions.
polynomial ldivide_polynomial(const polynomial &lhs, const polynomial &rhs)
Bridge (ldivide).
automaton cerny(const context &ctx, unsigned num_states)
Produce a Černý automaton of num_states states.
weight weight_zero(const context &c)
The weight zero.
static Registry< weight_series_t > & weight_series_registry()
static Registry< multiply_repeated_t > & multiply_repeated_registry()
static Registry< multiply_label_t > & multiply_label_registry()
static Registry< tuple_expansion_t > & tuple_expansion_registry()