Vcsn  2.4
Be Rational
vcsn Namespace Reference

Namespaces

 ast
 
 ctx
 
 detail
 
 detail_info
 
 dyn
 
 rat
 

Classes

struct  a_star_tag
 A-Star implementation (from vcsn/algos/a-star.hh). More...
 
struct  any
 Whether some of the values evaluate as true. More...
 
struct  are_composable
 Whether two contexts are composable. More...
 
class  are_isomorphicer
 
struct  are_labelsets_composable
 Whether two labelsets are composable. More...
 
struct  are_labelsets_composable< tupleset< LS1, LS2 >, tupleset< LS2, LS3 > >
 
struct  as_pair
 
struct  as_tuple
 
struct  auto_tag
 Tag to request the most appropriate version of an algorithm. More...
 
class  automaton_editor
 Abstract Builder (the design pattern) for automata. More...
 
class  automatonset
 
struct  bellman_ford_tag
 Bellman-Ford implementation (from vcsn/algos/bellman-ford.hh). More...
 
struct  boolean_tag
 Request the Boolean specialization for determinization (B and F2). More...
 
struct  brzozowski_tag
 Request for Brzozowski implementation of minimize (B and free). More...
 
class  char_letters
 Represent alphabets whose "letters" are plain chars. More...
 
struct  container_filter_range
 
struct  container_range
 Restrict the interface of a container to begin/end. More...
 
class  context
 
struct  cross_sequences
 Provide a range that allows to iterate over the cross product of the provided ranges. More...
 
struct  deterministic_tag
 Tag for operations on deterministic automata. More...
 
struct  dijkstra_tag
 Dijkstra implementation. More...
 
struct  discrete_chooser
 Random selector on container, using discrete distribution. More...
 
struct  dyn_vector_vnamer
 The vname of a vector of dyn:: objects (e.g., automaton, expression, ...) is the tuple of their vnames. More...
 
class  edit_automaton
 Concrete Builder (the design pattern) for automata. More...
 
struct  empty_t
 Empty labels, for LAO. More...
 
class  equal_to
 This is useful to make hashes with labels or weights as keys without using non-default constructors; to be used along with vcsn::hash. More...
 
class  file_library
 Manage search paths. More...
 
class  format
 An input/output format for valuesets. More...
 
struct  general_tag
 Tag for operations on all automata. More...
 
struct  getarg
 A mapping from strings to Values. More...
 
class  hash
 This is useful to make hashes with labels or weights as keys without using non-default constructors; to be used along with vcsn::equal_to. More...
 
struct  hopcroft_tag
 Request for Hopcroft implementation of minimize (B and free). More...
 
struct  integral_constant
 A simple placeholder for integral constants. More...
 
struct  iomanipulator
 Defines the operator() for the classes get_type, set_type and swap_type. More...
 
struct  is_lal
 
struct  is_lan
 
struct  is_lao
 
struct  is_lar
 
struct  is_lat
 
struct  is_law
 
struct  is_tropical
 
struct  is_tropical< nmin >
 
struct  is_tropical< rmin >
 
struct  is_tropical< zmin >
 
struct  kosaraju_tag
 Request the Kosaraju's algorithm to compute the SCCs. More...
 
struct  labels_are_expressions
 
struct  labels_are_letters
 
struct  labels_are_nullable
 
struct  labels_are_one
 
struct  labels_are_tuples
 
struct  labels_are_words
 
class  lazy_automaton_editor
 Build an automaton with unknown context. More...
 
struct  less
 Functor to compare Values of ValueSets. More...
 
struct  less_equal
 Functor to compare Values of ValueSets. More...
 
class  letterset
 Implementation of labels are letters. More...
 
struct  MilitaryOrder
 Military strict order predicate. More...
 
struct  moore_tag
 Request for Moore implementation of minimize (B and free). More...
 
class  nullableset
 Implementation of labels are nullables (letter or empty). More...
 
class  oneset
 Implementation of labels are ones: there is a single instance of label. More...
 
class  path
 Paths in filesystems, i.e., file names. More...
 
struct  possibly_labeled_transition_tuple
 Transition on non-empty label. More...
 
struct  possibly_labeled_transition_tuple< State, empty_t >
 Transition on empty label. More...
 
struct  random_selector
 Random selector on container, using uniform distribution. More...
 
class  set_alphabet
 A set of letters of type L. More...
 
struct  signature
 Signature of a function call. More...
 
struct  signature_tag
 Request for Moore implementation of minimize (B). More...
 
struct  snamer
 
struct  snamer< bool >
 
struct  snamer< boost::optional< unsigned > >
 
struct  snamer< const std::set< std::pair< std::string, std::string > > >
 
struct  snamer< const std::string >
 
struct  snamer< const std::vector< unsigned > >
 
struct  snamer< float >
 
struct  snamer< int >
 
struct  snamer< std::integral_constant< T, Value > >
 
struct  snamer< std::istream >
 
struct  snamer< std::ostream >
 
struct  snamer< std::shared_ptr< T > >
 
struct  snamer< std::tuple< Args... > >
 The sname of a tuple is the tuple of the snames. More...
 
struct  snamer< unsigned >
 
struct  snamer< vcsn::direction >
 
struct  snamer< vcsn::rat::identities >
 
class  sparse_map
 Sparse Map implementation. More...
 
class  sparse_set
 Sparse Set implementation. More...
 
struct  standard_tag
 Tag for operations on standard automata. More...
 
class  stateset
 State labelset. More...
 
class  string_letters
 Represent alphabets whose "letters" are strings. More...
 
struct  tarjan_iterative_tag
 Request the Tarjan's algorithm to compute the SCCs, implemented with explicit stack handling. More...
 
struct  tarjan_recursive_tag
 Request the Tarjan's algorithm to compute the SCCs, implemented with recursion. More...
 
class  to
 An exponent, or range of exponents. More...
 
struct  transition_tuple
 Transition with label and non Boolean weight. More...
 
struct  transition_tuple< State, Label, bool >
 Transition with label and Boolean weight. More...
 
struct  vnamer
 
struct  vnamer< bool >
 
struct  vnamer< boost::optional< unsigned > >
 
struct  vnamer< const std::set< std::pair< std::string, std::string > > >
 
struct  vnamer< const std::string >
 
struct  vnamer< const std::vector< dyn::automaton > >
 vector<dyn::automaton> -> std::tuple<automaton_t, ...>. More...
 
struct  vnamer< const std::vector< dyn::context > >
 vector<dyn::context> -> std::tuple<context_t, ...>. More...
 
struct  vnamer< const std::vector< dyn::expansion > >
 vector<dyn::expansion> -> std::tuple<expansion_t, ...>. More...
 
struct  vnamer< const std::vector< dyn::expression > >
 vector<dyn::expression> -> std::tuple<expression_t, ...>. More...
 
struct  vnamer< const std::vector< dyn::label > >
 vector<dyn::label> -> std::tuple<label_t, ...>. More...
 
struct  vnamer< const std::vector< dyn::polynomial > >
 vector<dyn::polynomial> -> std::tuple<polynomial_t, ...>. More...
 
struct  vnamer< const std::vector< dyn::weight > >
 vector<dyn::weight> -> std::tuple<weight_t, ...>. More...
 
struct  vnamer< const std::vector< unsigned > >
 
struct  vnamer< float >
 
struct  vnamer< int >
 
struct  vnamer< integral_constant >
 
struct  vnamer< std::integral_constant< T, Value > >
 
struct  vnamer< std::istream >
 
struct  vnamer< std::ostream >
 
struct  vnamer< unsigned >
 
struct  vnamer< vcsn::direction >
 
struct  vnamer< vcsn::rat::identities >
 
struct  weighted_tag
 Request for the weighted version of an algorithm. More...
 
struct  weightset_mixin
 Provide a variadic mul on top of a binary mul(), and one(). More...
 
struct  welement
 Storage for a label and a non-null weight. More...
 
class  wordset
 Implementation of labels are words. More...
 
class  xalloc
 Allocate slots in std::ostreams. More...
 
struct  yen_tag
 Yen implementation. More...
 
struct  zip_sequences
 
struct  zip_sequences_padded
 
struct  zipped_maps
 

Typedefs

template<Automaton Aut>
using states_t = std::unordered_set< state_t_of< Aut >>
 
template<bool Lazy, Automaton Lhs, Automaton Rhs>
using compose_automaton = std::shared_ptr< detail::compose_automaton_impl< Lazy, Lhs, Rhs >>
 A compose automaton as a shared pointer. More...
 
template<typename ExpSet >
using derived_term_automaton = std::shared_ptr< detail::derived_term_automaton_impl< ExpSet >>
 A derived-term automaton as a shared pointer. More...
 
template<Automaton Aut, wet_kind_t Kind, bool Lazy = false>
using determinized_automaton = std::shared_ptr< detail::determinized_automaton_impl< Aut, Kind, Lazy >>
 A determinized automaton as a shared pointer. More...
 
template<Automaton Aut>
using lazy_proper_automaton = std::shared_ptr< detail::lazy_proper_automaton_impl< Aut >>
 
template<Automaton Aut, bool Trans = false>
using filter_automaton = std::shared_ptr< detail::filter_automaton_impl< Aut, Trans >>
 
template<Automaton Aut>
using delay_automaton = std::shared_ptr< detail::delay_automaton_impl< Aut >>
 An automaton wrapper that presents the delay automaton. More...
 
template<std::size_t Tape, Automaton Aut>
using focus_automaton = std::shared_ptr< detail::focus_automaton_impl< Tape, Aut >>
 A focus automaton as a shared pointer. More...
 
template<Automaton Aut>
using synchronized_automaton = std::shared_ptr< detail::synchronized_automaton_impl< Aut >>
 An automaton wrapper that presents the synchronized automaton. More...
 
template<Automaton Aut>
using transpose_automaton = std::shared_ptr< detail::transpose_automaton_impl< Aut >>
 An automaton wrapper that presents the transposed automaton. More...
 
using letter_class_t = std::set< std::pair< std::string, std::string >>
 A set of letter ranges. More...
 
template<Automaton Aut>
using insplit_automaton = detail::insplit_automaton< Aut >
 An insplit automaton as a shared pointer. More...
 
template<Automaton Aut>
using codeterminized_automaton = transpose_automaton< determinized_automaton< decltype(transpose(std::declval< Aut >())), wet_kind_t::bitset >>
 The type of the codeterminized automaton. More...
 
template<typename ValueSet >
using add_mem_fn_t = decltype(std::declval< ValueSet >().add(std::declval< typename ValueSet::value_t >(), std::declval< typename ValueSet::value_t >()))
 The type of the add member function in valuesets. More...
 
template<typename ValueSet >
using has_add_mem_fn = detail::detect< ValueSet, add_mem_fn_t >
 Whether ValueSet features an add() member function. More...
 
template<Automaton Aut>
using pair_automaton = std::shared_ptr< detail::pair_automaton_impl< Aut >>
 
template<Automaton Aut>
using partial_identity_context_t_of = typename detail::partial_identity_context< Aut >::context_t
 
template<Automaton Aut>
using quotient_t = partition_automaton_t< Aut >
 The return type when calling quotient on Aut. More...
 
template<Automaton Aut>
using scc_automaton = std::shared_ptr< detail::scc_automaton_impl< Aut >>
 
template<typename Aut >
using predecessors_t_of = std::vector< transition_t_of< Aut >>
 A state-indexed vector of predecessor transitions from the path path. More...
 
template<typename Aut >
using path_t_of = std::vector< transition_t_of< Aut >>
 A list of transitions representing a path. More...
 
template<typename Context >
using mutable_automaton = std::shared_ptr< detail::mutable_automaton_impl< Context >>
 
template<Automaton Aut>
using name_automaton = std::shared_ptr< detail::name_automaton_impl< Aut >>
 
template<Automaton Aut>
using permutation_automaton = std::shared_ptr< detail::permutation_automaton_impl< Aut >>
 A permutation automaton as a shared pointer. More...
 
template<Automaton Aut>
using expression_automaton = std::shared_ptr< detail::expression_automaton_impl< Aut >>
 An expression automaton as a shared pointer. More...
 
template<typename... ValueSets>
using join_t = decltype(join(std::declval< ValueSets >()...))
 The type of the join of the ValueSets. More...
 
template<Automaton Aut>
using partition_automaton = std::shared_ptr< detail::partition_automaton_impl< Aut >>
 A partition automaton as a shared pointer. More...
 
template<Automaton Aut>
using partition_automaton_t = typename detail::partition_automaton_t_impl< Aut >::type
 The return type when calling quotient on Aut. More...
 
template<typename Context >
using expressionset = weightset_mixin< rat::expressionset_impl< Context >>
 
template<typename ExpSet >
using expansionset = rat::expansionset< ExpSet >
 
template<Automaton... Auts>
using tuple_automaton = std::shared_ptr< detail::tuple_automaton_impl< Auts... >>
 A tuple automaton as a shared pointer. More...
 
template<typename... ValueSets>
using meet_t = decltype(meet(std::declval< ValueSets >()...))
 
template<typename T >
using base_t = std::remove_cv_t< std::remove_reference_t< T >>
 T without reference or const/volatile qualifiers. More...
 
template<typename ValueSet >
using context_t_of = typename detail::context_t_of_impl< base_t< ValueSet >>::type
 
template<typename ValueSet >
using label_t_of = typename detail::label_t_of_impl< base_t< ValueSet >>::type
 
template<typename ValueSet >
using labelset_t_of = typename detail::labelset_t_of_impl< base_t< ValueSet >>::type
 
template<typename ValueSet >
using state_t_of = typename detail::state_t_of_impl< base_t< ValueSet >>::type
 
template<typename ValueSet >
using transition_t_of = typename detail::transition_t_of_impl< base_t< ValueSet >>::type
 
template<typename ValueSet >
using weight_t_of = typename detail::weight_t_of_impl< base_t< ValueSet >>::type
 
template<typename ValueSet >
using weightset_t_of = typename detail::weightset_t_of_impl< base_t< ValueSet >>::type
 
template<typename Aut , typename Context = context_t_of<Aut>>
using fresh_automaton_t_of = typename Aut::element_type::template fresh_automaton_t< Context >
 Given an automaton type, the type of its copies. More...
 
template<typename ValueSet >
using letter_t_of = typename labelset_t_of< base_t< ValueSet >>::letter_t
 
template<typename ValueSet >
using word_t_of = typename labelset_t_of< base_t< ValueSet >>::word_t
 
template<typename... LabelSets>
using tupleset = weightset_mixin< detail::tupleset_impl< LabelSets... >>
 
using dynamic_bitset = boost::dynamic_bitset<>
 
using symbol = boost::flyweight< std::string, boost::flyweights::no_tracking, boost::flyweights::intermodule_holder >
 An internalized string. More...
 
template<size_t I, typename T >
using tuple_element_t = typename std::tuple_element< I, T >::type
 C++14. More...
 
template<bool B>
using bool_constant = std::integral_constant< bool, B >
 
template<typename Key , typename Value , wet_kind_t Kind = detail::wet_kind<Key, Value>(), typename Compare = std::less<Key>, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using wet = detail::wet_impl< Kind, Key, Value, Compare, Hash, KeyEqual >
 Given Key/Value types, the appropriate weighted set type. More...
 
template<typename Context , wet_kind_t Kind = detail::wet_kind<labelset_t_of<Context>, weightset_t_of<Context>>()>
using wet_of = wet< label_t_of< Context >, weight_t_of< Context >, Kind, vcsn::less< labelset_t_of< Context >>, vcsn::hash< labelset_t_of< Context >>, vcsn::equal_to< labelset_t_of< Context >>>
 The corresponding wet for a LabelSet -> WeightSet context. More...
 
using b = weightset_mixin< detail::b_impl >
 
using f2 = weightset_mixin< detail::f2_impl >
 
using log = weightset_mixin< detail::log_impl >
 
using nmin = weightset_mixin< detail::nmin_impl >
 
using q = weightset_mixin< detail::q_impl >
 
using qmp = weightset_mixin< detail::qmp_impl >
 
using r = weightset_mixin< detail::r_impl >
 
using rmin = weightset_mixin< detail::rmin_impl >
 
using z = weightset_mixin< detail::z_impl >
 
using zmin = weightset_mixin< detail::zmin_impl >
 
template<typename Context , wet_kind_t Kind = detail::wet_kind<labelset_t_of<Context>, weightset_t_of<Context>>()>
using polynomialset = weightset_mixin< detail::polynomialset_impl< Context, Kind >>
 

Enumerations

enum  scc_algo_t {
  scc_algo_t::auto_, scc_algo_t::dijkstra, scc_algo_t::tarjan_iterative, scc_algo_t::tarjan_recursive,
  scc_algo_t::kosaraju
}
 
enum  to_expression_heuristic_t { to_expression_heuristic_t::best, to_expression_heuristic_t::delgado, to_expression_heuristic_t::delgado_label, to_expression_heuristic_t::naive }
 
enum  direction { direction::forward, direction::backward }
 Orientation. More...
 
enum  star_status_t { ABSVAL, NON_STARRABLE, STARRABLE, TOPS }
 
enum  wet_kind_t { wet_kind_t::bitset, wet_kind_t::map, wet_kind_t::set, wet_kind_t::unordered_map }
 Different implementations of wets. More...
 

Functions

template<Automaton Aut>
std::vector< transition_t_of< Aut > > lightest_path (const Aut &aut, state_t_of< Aut > source, state_t_of< Aut > dest, a_star_tag)
 
template<Automaton Aut>
states_t< Aut > accessible_states (const Aut &aut, bool strict=true)
 The set of accessible states, including pre(), and possibly post(). More...
 
template<Automaton Aut>
states_t< Aut > coaccessible_states (const Aut &a, bool strict=true)
 The set of coaccessible states, including post(), and possibly pre(). More...
 
template<Automaton Aut>
states_t< Aut > useful_states (const Aut &a, bool strict=true)
 The set of useful states, including possibly pre() and post(). More...
 
template<Automaton Aut>
size_t num_accessible_states (const Aut &a)
 Number of accessible states, not counting pre() and post(). More...
 
template<Automaton Aut>
size_t num_coaccessible_states (const Aut &a)
 Number of accessible states, not counting pre() and post(). More...
 
template<Automaton Aut>
size_t num_useful_states (const Aut &a)
 Number of accessible states, not counting pre() and post(). More...
 
template<Automaton Aut>
filter_automaton< Aut > accessible (const Aut &a)
 Accessible part of an automaton. More...
 
template<Automaton Aut>
filter_automaton< Aut > coaccessible (const Aut &a)
 Coaccessible part of an automaton. More...
 
template<Automaton Aut>
filter_automaton< Aut > trim (const Aut &a)
 Useful part of an automaton. More...
 
template<Automaton Aut>
bool is_trim (const Aut &a)
 Whether all its states are useful. More...
 
template<Automaton Aut>
bool is_useless (const Aut &a)
 Whether all no state is useful. More...
 
template<Automaton Aut>
bool is_accessible (const Aut &a)
 Whether all its states are accessible. More...
 
template<Automaton Aut>
bool is_coaccessible (const Aut &a)
 Whether all its states are coaccessible. More...
 
template<Automaton Aut>
bool is_empty (const Aut &a)
 Whether has no states. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & add_here (Aut1 &res, const Aut2 &b, standard_tag)
 Merge transitions of b into those of res. More...
 
template<Automaton Aut1, Automaton Aut2>
auto add_here (Aut1 &res, const Aut2 &b, deterministic_tag)
 
template<Automaton Aut1, Automaton Aut2>
auto add (const Aut1 &lhs, const Aut2 &rhs, deterministic_tag)
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & add_here (Aut1 &res, const Aut2 &b, general_tag)
 Merge transitions of b into those of res. More...
 
template<Automaton Aut1, Automaton Aut2, typename Tag = general_tag>
auto add (const Aut1 &lhs, const Aut2 &rhs, Tag tag={}) -> decltype(join_automata(lhs, rhs))
 The sum of two automata. More...
 
template<typename ValueSet >
ValueSet::value_t add (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Sums of values. More...
 
template<Automaton Aut1, Automaton Aut2>
auto are_equivalent (const Aut1 &a1, const Aut2 &a2) -> std::enable_if_t<(std::is_same< weightset_t_of< Aut1 >, b >::value &&std::is_same< weightset_t_of< Aut2 >, b >::value), bool >
 Check equivalence between Boolean automata on a free labelset. More...
 
template<typename ExpSet1 , typename ExpSet2 >
auto are_equivalent (const ExpSet1 &rs1, const typename ExpSet1::value_t r1, const ExpSet2 &rs2, const typename ExpSet2::value_t r2) -> bool
 Check equivalence between two expressions. More...
 
template<Automaton Lhs, Automaton Rhs>
fresh_automaton_t_of< Lhs > difference (const Lhs &lhs, const Rhs &rhs)
 An automaton that computes weights of lhs, but not by rhs. More...
 
template<typename ExpSet >
ExpSet::value_t difference (const ExpSet &rs, const typename ExpSet::value_t &lhs, const typename ExpSet::value_t &rhs)
 Difference of expressions. More...
 
template<Automaton Aut1, Automaton Aut2>
bool are_isomorphic (const Aut1 &a1, const Aut2 &a2)
 
template<Automaton Aut>
std::vector< transition_t_of< Aut > > lightest_path (const Aut &aut, state_t_of< Aut > source, state_t_of< Aut >, bellman_ford_tag)
 Destination is ignored as bellman-ford does not stop when reaching dest, but when each iteration has been done. More...
 
template<typename Ctx >
mutable_automaton< Ctx > cerny (const Ctx &ctx, unsigned num_states)
 Cerny automata are automata whose synchronizing word length is always (n - 1)^2, the upper bound of the Cerny's conjecture. More...
 
template<Automaton Aut>
void complement_here (Aut &aut)
 
template<Automaton Aut>
auto complement (const Aut &aut) -> decltype(copy(aut))
 
template<Automaton Aut>
Aut & complete_here (Aut &aut)
 Complete aut and return it. More...
 
template<Automaton Aut>
auto complete (const Aut &aut) -> decltype(::vcsn::copy(aut))
 A complete copy of aut. More...
 
template<typename ValueSet >
ValueSet::value_t compose (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Composition of values. More...
 
template<bool Lazy, std::size_t OutTape, std::size_t InTape, Automaton Lhs, Automaton Rhs>
auto make_compose_automaton (const Lhs &lhs, const Rhs &rhs)
 
template<Automaton Lhs, Automaton Rhs, std::size_t OutTape = 1, std::size_t InTape = 0>
auto compose (const Lhs &lhs, const Rhs &rhs)
 Build the (accessible part of the) composition. More...
 
template<typename Lhs , typename Rhs , std::size_t OutTape = 1, std::size_t InTape = 0>
auto compose_lazy (const Lhs &lhs, const Rhs &rhs)
 Build the (accessible part of the) lazy composition. More...
 
template<Automaton Aut>
Aut conjugate (const Aut &aut)
 
template<Automaton Aut1, Automaton Aut2>
auto ldivide (const Aut1 &lhs, const Aut2 &rhs, auto_tag={})
 Compute the left quotient. More...
 
template<Automaton Aut1, Automaton Aut2>
auto ldivide (const Aut1 &lhs, const Aut2 &rhs, boolean_tag)
 
template<Automaton Aut1, Automaton Aut2>
auto ldivide (const Aut1 &lhs, const Aut2 &rhs, weighted_tag)
 
template<Automaton Aut1, Automaton Aut2>
auto rdivide (const Aut1 &a1, const Aut2 &a2)
 Compute the right quotient. More...
 
template<Automaton... Auts>
auto shuffle (const Auts &...as) -> tuple_automaton< decltype(join_automata(as...)), Auts... >
 The (accessible part of the) shuffle product. More...
 
template<typename ValueSet >
ValueSet::value_t shuffle (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Shuffle product of expressions. More...
 
template<Automaton A1, Automaton A2>
auto infiltrate (const A1 &a1, const A2 &a2) -> tuple_automaton< decltype(join_automata(a1, a2)), A1, A2 >
 The (accessible part of the) infiltration product. More...
 
template<Automaton A1, Automaton A2, Automaton A3, Automaton... Auts>
auto infiltrate (const A1 &a1, const A2 &a2, const A3 &a3, const Auts &...as) -> decltype(infiltrate(infiltrate(a1, a2), a3, as...))
 The (accessible part of the) infiltration product. More...
 
template<typename ValueSet >
ValueSet::value_t infiltrate (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Infiltration product of expressions. More...
 
template<Automaton Aut>
auto conjunction (const Aut &aut, to exp) -> fresh_automaton_t_of< Aut >
 Repeated conjunction of a automaton. More...
 
template<typename ValueSet >
ValueSet::value_t conjunction (const ValueSet &rs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Intersection/Hadamard product of expressions/polynomials. More...
 
template<typename ExpSet >
weight_t_of< ExpSet > constant_term (const ExpSet &rs, const typename ExpSet::value_t &e)
 The constant term of e. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>>
AutOut make_fresh_automaton (const AutIn &model)
 Create an empty, mutable, automaton, based on another one. More...
 
template<Automaton AutIn, Automaton AutOut>
detail::copier< AutIn, AutOut > make_copier (const AutIn &in, AutOut &out, bool safe=true)
 Build an automaton copier. More...
 
template<Automaton AutIn, Automaton AutOut, typename KeepState , typename KeepTrans >
void copy_into (const AutIn &in, AutOut &out, KeepState keep_state, KeepTrans keep_trans)
 Copy selected states and transitions of an automaton. More...
 
template<Automaton AutIn, Automaton AutOut, typename KeepState >
void copy_into (const AutIn &in, AutOut &out, KeepState keep_state)
 Copy the selected states an automaton. More...
 
template<Automaton AutIn, Automaton AutOut>
void copy_into (const AutIn &in, AutOut &out)
 Copy an automaton. More...
 
template<Automaton AutIn, Automaton AutOut>
void copy_into (const AutIn &in, AutOut &out, bool safe)
 Copy an automaton. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename KeepState , typename KeepTrans >
auto copy (const AutIn &input, KeepState keep_state, KeepTrans keep_trans) -> decltype(keep_state(input->null_state()), keep_trans(input->null_transition()), make_fresh_automaton< AutIn, AutOut >(input))
 A copy of input keeping only its states that are accepted by keep_state, and transitions accepted by keep_trans. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename KeepState >
auto copy (const AutIn &input, KeepState keep_state) -> decltype(keep_state(input->null_state()), make_fresh_automaton< AutIn, AutOut >(input))
 A copy of input. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>>
AutOut copy (const AutIn &input)
 A copy of input. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename States >
auto copy (const AutIn &input, const States &ss) -> decltype(*ss.begin()==input->null_state(), make_fresh_automaton< AutIn, AutOut >(input))
 A copy of input keeping only its states that are members of states. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename States , typename Trans >
auto copy (const AutIn &input, const States &ss, const Trans &ts) -> decltype(*ss.begin()==input->null_state(), *ts.begin()==input->null_transition(), make_fresh_automaton< AutIn, AutOut >(input))
 A copy of input keeping only its states that are members of container ss, and transitions that are members of container ts. More...
 
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename Transitions >
auto copy (const AutIn &input, const Transitions &ts) -> decltype(*ts.begin()==input->null_transition(), make_fresh_automaton< AutIn, AutOut >(input))
 A copy of input keeping only its transitions that are members of ts, and the states on which these transitions depend. More...
 
template<Automaton Aut>
std::ostream & daut (const Aut &aut, std::ostream &out=std::cout)
 Print an automaton in Daut format. More...
 
template<typename Context >
mutable_automaton< Context > de_bruijn (const Context &ctx, unsigned n)
 
template<typename ExpSet >
rat::expression_polynomial_t< ExpSet > derivation (const ExpSet &rs, const typename ExpSet::value_t &e, label_t_of< ExpSet > a, bool breaking)
 Derive an expression wrt to a letter. More...
 
template<typename ExpSet >
rat::expression_polynomial_t< ExpSet > derivation (const ExpSet &rs, const rat::expression_polynomial_t< ExpSet > &p, label_t_of< ExpSet > a, bool breaking=false)
 Derive a polynomial of expressions wrt to a letter. More...
 
template<typename ExpSet , typename = std::enable_if_t<!std::is_same<word_t_of<ExpSet>, label_t_of<ExpSet>>{}>>
rat::expression_polynomial_t< ExpSet > derivation (const ExpSet &rs, const typename ExpSet::value_t &e, const word_t_of< ExpSet > &l, bool breaking=false)
 Derive an expression wrt to a word. More...
 
template<typename ExpSet >
auto make_derived_term_automaton (const ExpSet &rs, const detail::derived_term_algo &algo) -> derived_term_automaton< ExpSet >
 
template<typename ExpSet >
std::enable_if_t< labelset_t_of< ExpSet >::is_letterized(), expression_automaton< mutable_automaton< typename ExpSet::context_t > > > derived_term (const ExpSet &rs, const typename ExpSet::value_t &r, const std::string &algo="auto")
 The derived-term automaton, for letterized labelsets. More...
 
template<typename ExpSet >
std::enable_if_t<!labelset_t_of< ExpSet >::is_letterized(), expression_automaton< mutable_automaton< typename ExpSet::context_t > > > derived_term (const ExpSet &rs, const typename ExpSet::value_t &r, const std::string &algo="auto")
 The derived-term automaton, for non letterized labelsets. More...
 
template<Automaton Aut, typename Tag , bool Lazy = false>
auto determinize (const Aut &a, Tag={}, bool_constant< Lazy >={})
 
template<Automaton Aut, bool Lazy = false>
auto determinize (const Aut &a, auto_tag={}, bool_constant< Lazy > lazy={})
 Determinization: automatic dispatch based on the automaton type. More...
 
template<Automaton Aut, typename Tag = auto_tag>
auto codeterminize (const Aut &aut, Tag tag={})
 
template<Automaton Aut>
std::vector< transition_t_of< Aut > > lightest_path (const Aut &aut, state_t_of< Aut > source, state_t_of< Aut > dest, dijkstra_tag)
 
template<Automaton Aut>
std::vector< weight_t_of< Aut > > ss_shortest_distance (const Aut &aut, state_t_of< Aut > s0)
 Single source shortest distance. More...
 
template<Automaton Aut>
std::unordered_map< state_t_of< Aut >, std::pair< unsigned, transition_t_of< Aut > > > paths_ibfs (const Aut &aut, const std::vector< state_t_of< Aut >> &start)
 Find the shortest paths from some states to all the states. More...
 
template<Automaton Aut>
std::vector< std::vector< weight_t_of< Aut > > > all_distances (const Aut &aut)
 
template<typename ValueSet >
ValueSet::value_t ldivide (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Left-division of values. More...
 
template<typename ValueSet >
ValueSet::value_t lgcd (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Left-division of values. More...
 
template<typename ValueSet >
ValueSet::value_t rdivide (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Right-division of values. More...
 
template<typename Context >
mutable_automaton< Context > divkbaseb (const Context &ctx, unsigned divisor, unsigned base)
 Build the Boolean automaton which accepts a word n representing a number in base "base" if and only if divisor|n. More...
 
template<Automaton Aut>
std::ostream & dot (const Aut &aut, std::ostream &out=std::cout, format fmt={}, bool mathjax=false)
 Print an automaton in Graphviz's Dot format. More...
 
template<typename Context >
mutable_automaton< Context > double_ring (const Context &ctx, unsigned n, const std::vector< unsigned > &finals)
 
template<Automaton Aut>
std::ostream & efsm (const Aut &aut, std::ostream &out=std::cout)
 Print automaton to EFSM format, based on FSM format. More...
 
template<Automaton Aut>
auto evaluate (const Aut &a, const word_t_of< Aut > &w) -> std::enable_if_t<!context_t_of< Aut >::is_lao, weight_t_of< Aut >>
 General case of evaluation. More...
 
template<Automaton Aut>
auto evaluate (const Aut &a) -> std::enable_if_t< context_t_of< Aut >::is_lao, weight_t_of< Aut >>
 Evaluation for lao automaton. More...
 
template<Automaton Aut>
auto evaluate (const Aut &a, const typename detail::word_polynomialset_t< context_t_of< Aut >>::value_t &p) -> weight_t_of< Aut >
 Evaluation of a polynomial. More...
 
template<typename ExpSet >
ExpSet::value_t expand (const ExpSet &rs, const typename ExpSet::value_t &r)
 Expand a typed expression, i.e., distribute multiplications over sums. More...
 
template<Automaton Aut, bool Trans = false>
filter_automaton< Aut, Trans > filter (const Aut &aut, boost::optional< dynamic_bitset > ss={}, boost::optional< dynamic_bitset > ts={})
 Get an automaton who is a part state set ss of aut. More...
 
template<Automaton Aut>
filter_automaton< Aut > filter (const Aut &aut, const std::unordered_set< state_t_of< Aut >> &ss)
 
template<unsigned Tape, Automaton Aut>
focus_automaton< Tape, Aut > focus (Aut aut)
 
template<Automaton Aut>
bool in_situ_remover (Aut &aut, bool prune=true)
 
template<Automaton Aut>
bool is_ambiguous (const Aut &aut)
 Whether an automaton is ambiguous. More...
 
template<Automaton Aut>
bool is_proper (const Aut &aut) ATTRIBUTE_CONST
 Test whether an automaton is proper. More...
 
template<Automaton Aut>
bool is_valid (const Aut &aut)
 
template<typename ExpSet >
bool is_valid (const ExpSet &rs, const typename ExpSet::value_t &e)
 Whether e has only computable stars. More...
 
template<typename ExpSet >
rat::expansionset< ExpSet >::value_t to_expansion (const ExpSet &rs, const typename ExpSet::value_t &e)
 First order expansion. More...
 
template<Automaton Aut>
std::ostream & fado (const Aut &aut, std::ostream &out=std::cout)
 Format automaton to FAdo format. More...
 
template<Automaton Aut>
std::ostream & grail (const Aut &aut, std::ostream &out)
 Print automaton in Grail format. More...
 
template<Automaton Aut>
bool has_bounded_lag (const Aut &aut)
 Whether a transducer has a bounded lag. More...
 
template<Automaton Aut>
std::enable_if_t< weightset_t_of< Aut >::has_lightening_weights(), bool > has_lightening_cycle (const Aut &aut)
 
template<Automaton Aut>
std::enable_if_t<!weightset_t_of< Aut >::has_lightening_weights(), bool > has_lightening_cycle (const Aut &aut)
 
template<Automaton Aut>
bool cycle_identity (const detail::component_t< Aut > &c, const Aut &aut)
 Check the weight of two states on this component is unique. More...
 
template<Automaton AutIn, Automaton AutOut>
void create_states_and_trans_ (const AutIn &aut, AutOut &naut1, AutOut &naut2)
 Create states and the transitions two new automata naut1 and naut2 with weight of transition <(w, one)> and <(one, w)> corresponding with the weight of transition <w> of aut. More...
 
template<Automaton Aut>
bool has_twins_property (const Aut &aut)
 Whether aut has the twins property. More...
 
template<Automaton Aut, typename ExpSet , typename Tag >
Aut inductive (const ExpSet &rs, const typename ExpSet::value_t &r, Tag={})
 Build a inductive automaton from an expression. More...
 
template<Automaton Aut>
std::ostream & info (const Aut &aut, std::ostream &out=std::cout, unsigned details=2)
 Print info about an automaton. More...
 
template<typename ExpSet >
void info (const ExpSet &rs, const typename ExpSet::value_t &e, std::ostream &o=std::cout)
 Print info about the expression. More...
 
template<Automaton Aut>
ATTRIBUTE_CONST std::enable_if_t< context_t_of< Aut >::has_one(), bool > is_eps_acyclic (const Aut &aut)
 Detect epsilon-circuits. More...
 
template<Automaton Aut>
ATTRIBUTE_CONST std::enable_if_t<!context_t_of< Aut >::has_one(), bool > is_eps_acyclic (const Aut &)
 
template<Automaton Aut>
ATTRIBUTE_CONST bool is_acyclic (const Aut &aut)
 
template<Automaton Aut>
word_t_of< Aut > ambiguous_word (const Aut &aut)
 
template<Automaton Aut>
bool is_cycle_ambiguous (const Aut &aut)
 Whether aut is cycle-ambiguous. More...
 
template<Automaton Aut>
bool is_cycle_ambiguous_scc (const Aut &aut)
 Whether aut is cycle-ambiguous. More...
 
template<Automaton Aut>
bool is_complete (const Aut &aut)
 Whether aut is complete. More...
 
template<Automaton Aut>
bool is_deterministic (const Aut &aut, state_t_of< Aut > s)
 Whether state s is deterministic in aut. More...
 
template<Automaton Aut>
size_t num_deterministic_states (const Aut &aut)
 Number of non-deterministic states. More...
 
template<Automaton Aut>
size_t num_codeterministic_states (const Aut &aut)
 Number of non-deterministic states of transposed automaton. More...
 
template<Automaton Aut>
bool is_deterministic (const Aut &aut)
 Whether has at most an initial state, and all its states are deterministic. More...
 
template<Automaton Aut>
bool is_codeterministic (const Aut &aut)
 Whether the transposed automaton is deterministic. More...
 
template<Automaton Aut>
constexpr bool is_free_boolean ()
 
template<Automaton Aut>
bool is_functional (const Aut &aut)
 Whether aut is functional. More...
 
template<Automaton Aut>
bool is_partial_identity (const Aut &aut)
 Whether transducer aut is equivalent to a partial identity function on all successful paths. More...
 
template<Automaton Aut>
bool is_synchronized (const Aut &aut)
 Check whether the transducer is synchronized. More...
 
template<Automaton Aut>
auto make_delay_automaton (const Aut &aut) -> decltype(detail::make_delay_automaton(aut))
 Check whether the transducer is synchronized. More...
 
template<Automaton Aut>
std::vector< path_t_of< Aut > > k_lightest_path (const Aut &aut, state_t_of< Aut > src, state_t_of< Aut > dst, unsigned k)
 
template<Automaton Aut>
predecessors_t_of< Aut > format_lightest (const Aut &aut, const std::vector< transition_t_of< Aut >> &path)
 A state-indexed vector of predecessor transitions from the path path. More...
 
template<Automaton Aut>
predecessors_t_of< Aut > lightest_path (const Aut &aut, state_t_of< Aut > src, state_t_of< Aut > dst, yen_tag)
 
template<typename Context >
mutable_automaton< Context > ladybird (const Context &ctx, unsigned n)
 Build the ladybird automaton of n states. More...
 
template<typename ExpSet >
bool less_than (const ExpSet &rs, const typename ExpSet::value_t &lhs, const typename ExpSet::value_t &rhs)
 Whether lhs precedes rhs. More...
 
template<Automaton Aut>
auto letterize (const Aut &aut) -> decltype(detail::letterize(aut))
 Split the word transitions in the input automaton into letter ones. More...
 
template<Automaton Aut>
bool is_letterized (const Aut &aut)
 Check if the transitions are all letters. More...
 
template<Automaton Aut>
auto realtime (const Aut &aut) -> decltype(proper(::vcsn::letterize(aut)))
 Split the word transitions in the input automaton into letter ones, and remove the spontaneous transitions. More...
 
template<Automaton Aut>
bool is_realtime (const Aut &aut)
 Check if the automaton is realtime, i.e. More...
 
template<typename Context >
mutable_automaton< Context > levenshtein (const Context &ctx)
 The Levenshtein automaton for a given context. More...
 
template<Automaton Aut, size_t... Tapes>
detail::lifted_automaton_t< Aut, Tapes... > lift (const Aut &a, vcsn::rat::identities ids={})
 Lift some tapes of the transducer. More...
 
template<typename ExpSet >
detail::lifted_expressionset_t< ExpSet >::value_t lift (const ExpSet &rs, const typename ExpSet::value_t &e)
 Move all the labels to the weights. More...
 
template<Automaton Aut, typename Algo = auto_tag>
fresh_automaton_t_of< Aut > lightest_automaton (const Aut &aut, unsigned k, Algo algo={})
 Lightest Automaton. More...
 
template<Automaton Aut, typename Tag = auto_tag>
std::vector< transition_t_of< Aut > > lightest_path (const Aut &aut, Tag tag={})
 Lightest path dispatch between algorithms with tags. More...
 
template<Automaton Aut>
std::vector< transition_t_of< Aut > > lightest_path (const Aut &aut, state_t_of< Aut > source, state_t_of< Aut > dest, auto_tag={})
 
template<Automaton Aut>
std::vector< transition_t_of< Aut > > lightest_path (const Aut &aut, state_t_of< Aut > src, state_t_of< Aut > dst, const std::string &algo)
 Lightest path dispatch between algorithms with string. More...
 
template<Automaton Aut>
auto path_monomial (const Aut &aut, const std::vector< transition_t_of< Aut >> &path, state_t_of< Aut > src=Aut::element_type::pre(), state_t_of< Aut > dst=Aut::element_type::post()) -> boost::optional< typename detail::word_polynomialset_t< context_t_of< Aut >>::monomial_t >
 Given a path (typically computed by lightest_path), the corresponding monomial (label, weight). More...
 
template<Automaton Aut>
detail::word_polynomialset_t< context_t_of< Aut > >::value_t lightest (const Aut &aut, unsigned num=1, const std::string &algo="auto")
 The approximated behavior of an automaton. More...
 
template<typename Ctx >
Ctx make_context (const std::string &name)
 Build a context from its name. More...
 
template<typename Ctx >
constexpr auto num_tapes (const Ctx &) -> std::enable_if_t< Ctx::is_lat, size_t >
 
template<Automaton Aut>
auto minimize (const Aut &a, brzozowski_tag) -> std::enable_if_t< is_free_boolean< Aut >(), determinized_automaton< codeterminized_automaton< Aut >, wet_kind_t::bitset >>
 Brzozowski-based minimization. More...
 
template<Automaton Aut>
std::enable_if_t< is_free_boolean< Aut >), quotient_t< Aut > > minimize (const Aut &a, hopcroft_tag)
 
template<Automaton Aut, typename Tag >
auto minimize (const Aut &a, Tag) -> quotient_t< Aut >
 Minimization via the minimizer functors. More...
 
template<Automaton Aut>
std::enable_if_t< std::is_same< weightset_t_of< Aut >, b >::value, quotient_t< Aut > > minimize (const Aut &a, auto_tag={})
 Minimization for Boolean automata: auto_tag. More...
 
template<Automaton Aut>
std::enable_if_t<!std::is_same< weightset_t_of< Aut >, b >::value, quotient_t< Aut > > minimize (const Aut &a, auto_tag={})
 Minimization for non Boolean automata: auto_tag.. More...
 
template<Automaton Aut>
std::enable_if_t< is_free_boolean< Aut >), quotient_t< Aut > > minimize (const Aut &a, const std::string &algo)
 Minimization for Boolean automata on a free labelset: algo selection. More...
 
template<Automaton Aut>
std::enable_if_t< std::is_same< weightset_t_of< Aut >, b >::value &&!labelset_t_of< Aut >::is_free(), quotient_t< Aut > > minimize (const Aut &a, const std::string &algo)
 Minimization for Boolean automata on a non-free labelset: algo selection. More...
 
template<Automaton Aut>
std::enable_if_t<!std::is_same< weightset_t_of< Aut >, b >::value, quotient_t< Aut > > minimize (const Aut &a, const std::string &algo)
 Minimization for non Boolean automata: algo selection. More...
 
template<Automaton Aut, typename Tag = auto_tag>
auto cominimize (const Aut &a, Tag tag={}) -> decltype(transpose(minimize(transpose(a), tag)))
 Cominimization. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & multiply_here (Aut1 &res, const Aut2 &b, deterministic_tag)
 Append automaton b to res. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & multiply_here (Aut1 &res, const Aut2 &b, general_tag)
 Append automaton b to res for non standard automata. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & multiply_here (Aut1 &res, const Aut2 &b, standard_tag={})
 Append automaton b to res. More...
 
template<Automaton Aut1, Automaton Aut2, typename Tag = general_tag>
auto multiply (const Aut1 &lhs, const Aut2 &rhs, Tag tag={}) -> decltype(lhs->null_state(), rhs->null_state(), detail::make_join_automaton(tag, lhs, rhs))
 Concatenate two automata, general case. More...
 
template<Automaton Aut, typename Tag = general_tag>
auto multiply (const Aut &aut, to exp, Tag tag={}) -> decltype(aut->null_state(), detail::make_join_automaton(tag, aut))
 Repeated concatenation of an automaton. More...
 
template<typename ValueSet >
ValueSet::value_t multiply (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Product (concatenation) of expressions/labels/polynomials/weights. More...
 
template<typename ValueSet >
auto multiply (const ValueSet &vs, const typename ValueSet::value_t &v, const to &exp) -> std::enable_if_t<!has_add_mem_fn< ValueSet >
 Repeated multiplication of values that cannot be added. More...
 
return detail::static_if< detail::has_power_mem_fn< ValueSet >{}> ([](const auto &vs, const auto &v, auto n){return vs.power(v, n);}, [](const auto &vs, const auto &v, auto n){auto res=vs.one();if(!vs.is_one(v)) while(n--) res=vs.mul(res, v);return res;})(vs
 
 if (exp.max==-1)
 
 if (exp.min< exp.max)
 
template<Automaton Aut>
bool is_normalized (const Aut &a)
 Whether a is standard and co-standard. More...
 
template<Automaton Aut>
auto normalize (const Aut &a) -> decltype(copy(a))
 Normalize a automaton. More...
 
template<Automaton Aut>
pair_automaton< Aut > pair (const Aut &aut, bool keep_initials=false)
 
template<Automaton Aut>
fresh_automaton_t_of< Aut, partial_identity_context_t_of< Aut > > partial_identity (const Aut &aut)
 Create a partial identity transducer from aut. More...
 
template<Automaton Aut>
Aut & suffix_here (Aut &aut)
 Make all accessible states initial. More...
 
template<Automaton Aut>
auto suffix (const Aut &aut) -> decltype(::vcsn::copy(aut))
 
template<Automaton Aut>
Aut & prefix_here (Aut &aut)
 Make all coaccessible states final. More...
 
template<Automaton Aut>
auto prefix (const Aut &aut) -> decltype(::vcsn::copy(aut))
 
template<Automaton Aut>
Aut & factor_here (Aut &aut)
 Make each useful state both initial and final. More...
 
template<Automaton Aut>
auto factor (const Aut &aut) -> decltype(::vcsn::copy(aut))
 
template<Automaton Aut>
Aut & subword_here (Aut &aut)
 Add spontaneous transitions for each non spontaneous transition, with same source, destination and weight. More...
 
template<Automaton Aut>
auto subword (const Aut &aut) -> decltype(make_nullable_automaton(aut->context()))
 Apply subword_here() to a copy of aut. More...
 
template<Automaton Aut>
std::ostream & print (const Aut &aut, std::ostream &out=std::cout, const std::string &fmt="default")
 
template<typename ValueSet >
std::ostream & print (const ValueSet &vs, const typename ValueSet::value_t &v, std::ostream &o=std::cout, format fmt={})
 Print a value thanks to a valueset. More...
 
template<typename Context >
std::ostream & print (const expressionset< Context > &rs, const typename expressionset< Context >::value_t &r, std::ostream &o=std::cout, const std::string &fmt="default")
 Print an expression. More...
 
template<typename PolynomialSet >
std::ostream & list (const PolynomialSet &ps, const typename PolynomialSet::value_t &p, std::ostream &o=std::cout)
 
template<std::size_t Tape, Automaton Aut>
auto project (const Aut &aut) -> mutable_automaton< detail::project_context< Tape, context_t_of< Aut >>>
 
template<Automaton Aut>
auto proper (const Aut &aut, direction dir=direction::backward, bool prune=true, const std::string &algo="auto") -> fresh_automaton_t_of< Aut, detail::proper_context< context_t_of< Aut >>>
 Eliminate spontaneous transitions. More...
 
template<Automaton Aut>
auto proper_lazy (const Aut &aut, direction dir=direction::backward, bool prune=true) -> lazy_proper_automaton< Aut >
 
template<Automaton Aut>
void proper_here (Aut &aut, direction dir=direction::backward, bool prune=true, const std::string &algo="auto")
 Eliminate spontaneous transitions in place. More...
 
template<Automaton Aut>
weight_t_of< Aut > shortest_distance_to_finals (Aut aut, state_t_of< Aut > s0)
 Find shorhest of s0 to the final states of aut by using single source shortest distance. More...
 
template<Automaton Aut>
std::unordered_map< state_t_of< Aut >, weight_t_of< Aut > > shortest_distance_to_finals (Aut aut)
 Find all shortest distances of each state to the final states of aut. More...
 
template<Automaton Aut>
auto push_weights (const Aut &aut) -> decltype(::vcsn::copy(aut))
 The algorithm weight pushing. More...
 
template<Automaton Aut>
auto quotient (const Aut &a, typename detail::quotienter< Aut >::class_to_set_t &cs) -> quotient_t< Aut >
 
template<typename Context >
mutable_automaton< Context > quotkbaseb (const Context &ctx, unsigned divisor, unsigned base)
 Build the transducer which accepts a word n representing a number in base "base" and outputs the quotient of the division of n by k. More...
 
template<typename Ctx >
mutable_automaton< Ctx > random_automaton (const Ctx &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="")
 Produce a random automaton. More...
 
template<typename Ctx >
mutable_automaton< Ctx > random_automaton_deterministic (const Ctx &ctx, unsigned num_states)
 
template<typename ExpressionSet >
std::string random_expression_string (const ExpressionSet &rs, const std::string &param)
 Generate a random expression string. More...
 
template<typename ExpressionSet >
ExpressionSet::value_t random_expression (const ExpressionSet &rs, const std::string &param)
 Generate a random expression. More...
 
template<typename WeightSet >
WeightSet::value_t random_weight (const WeightSet &ws, const std::string &param={})
 Generate a random weight. More...
 
template<typename Context >
auto read_label (const Context &ctx, std::istream &is, bool quoted=false) -> label_t_of< Context >
 
template<typename Context >
auto read_polynomial (const Context &ctx, std::istream &is) -> typename polynomialset< Context >::value_t
 
template<typename Context >
auto read_weight (const Context &ctx, std::istream &is) -> weight_t_of< Context >
 
template<Automaton Aut>
auto left_reduce (const Aut &input) -> decltype(copy(input))
 
template<Automaton Aut>
auto reduce (const Aut &input) -> decltype(copy(input))
 
template<Automaton Aut>
std::vector< state_t_of< Aut > > reverse_postorder (const Aut &aut)
 Get all states in reverse postorder. More...
 
scc_algo_t scc_algo (const std::string &algo)
 
template<Automaton Aut, typename Tag = auto_tag>
const detail::components_t< Aut > strong_components (const Aut &aut, Tag={})
 Find all strongly connected components of aut. More...
 
template<Automaton Aut>
const detail::components_t< Aut > strong_components (const Aut &aut, scc_algo_t algo=scc_algo_t::tarjan_iterative)
 Find all strongly connected components of aut. More...
 
template<Automaton Aut>
fresh_automaton_t_of< Aut > aut_of_component (const detail::component_t< Aut > &com, const Aut &aut)
 Generate a subautomaton corresponding to an SCC. More...
 
template<Automaton Aut>
scc_automaton< Aut > scc (const Aut &aut, const std::string &algo="auto")
 Get scc_automaton from aut. More...
 
template<Automaton Aut>
std::size_t num_components (const scc_automaton< Aut > &aut)
 Get number of strongly connected components. More...
 
template<Automaton Aut>
std::size_t num_components (const Aut &)
 
template<Automaton Aut>
filter_automaton< scc_automaton< Aut > > component (const scc_automaton< Aut > &aut, unsigned num)
 An SCC as a subautomaton. More...
 
template<Automaton Aut>
void component (const Aut &, unsigned)
 
template<Automaton Aut>
partition_automaton< scc_automaton< Aut > > condense (const scc_automaton< Aut > &aut)
 Create a condensation of automaton with each its state who is a strongly connected component of aut. More...
 
template<Automaton Aut>
partition_automaton< Aut > condense (const Aut &)
 
template<Automaton Aut>
detail::enumerater< Aut >::polynomial_t shortest (const Aut &aut, boost::optional< unsigned > num={}, boost::optional< unsigned > len={})
 The approximated behavior of an automaton. More...
 
template<Automaton Aut>
detail::enumerater< Aut >::polynomial_t shortest (const Aut &aut, state_t_of< Aut > src, state_t_of< Aut > dst)
 The approximated behavior of a part of an automaton (looks for one word of unspecified length). More...
 
template<Automaton Aut>
detail::enumerater< Aut >::polynomial_t enumerate (const Aut &aut, unsigned len)
 The approximated behavior of an automaton. More...
 
template<Automaton Aut>
bool is_out_sorted (const Aut &a)
 Whether for each state, the outgoing transitions are sorted by increasing label. More...
 
template<Automaton Aut>
auto sort (const Aut &a) -> permutation_automaton< Aut >
 
template<typename ExpSet >
rat::expression_polynomial_t< ExpSet > split (const ExpSet &rs, const typename ExpSet::value_t &e)
 Split an expression. More...
 
template<typename PolynomialSet >
PolynomialSet::value_t split_polynomial (const PolynomialSet &ps, const typename PolynomialSet::value_t &p)
 Split a polynomial of expressions, given the polynomialset. More...
 
template<typename ExpSet >
rat::expression_polynomial_t< ExpSet > split (const ExpSet &rs, const rat::expression_polynomial_t< ExpSet > &p)
 Split a polynomial of expressions, given the expressionset. More...
 
template<Automaton Aut>
bool is_standard (const Aut &a)
 Whether a is standard. More...
 
template<Automaton Aut>
bool is_costandard (const Aut &a)
 Whether a is costandard. More...
 
template<Automaton Aut>
void standard_here (Aut &aut)
 Turn aut into a standard automaton. More...
 
template<Automaton Aut>
auto standard (const Aut &aut)
 
template<Automaton Aut>
auto costandard (const Aut &aut) -> decltype(copy(aut))
 
template<Automaton Aut, typename ExpSet >
Aut standard (const ExpSet &rs, const typename ExpSet::value_t &r)
 Build a standard automaton from an expression. More...
 
template<typename ExpSet >
unsigned star_height (const ExpSet &es, const typename ExpSet::value_t &e)
 Star height of an expression. More...
 
template<typename ExpSet >
ExpSet::value_t star_normal_form (const ExpSet &rs, const typename ExpSet::value_t &e)
 Star-normal form of an expression. More...
 
template<Automaton Aut>
Aut & star_here (Aut &res, general_tag={})
 In-place star of an automaton. More...
 
template<Automaton Aut>
Aut & star_here (Aut &res, standard_tag)
 In-place star of a standard automaton. More...
 
template<Automaton Aut>
Aut & star_here (Aut &res, deterministic_tag)
 In-place star of a deterministic automaton. More...
 
template<Automaton Aut, typename Tag = general_tag>
auto star (const Aut &aut, Tag tag={}) -> decltype(detail::make_join_automaton(tag, aut))
 Star of an automaton. More...
 
template<Automaton Aut>
auto strip (const Aut &aut)
 Remove (all) the decorations from a decorated automaton. More...
 
template<Automaton Aut>
auto synchronize (const Aut &aut) -> decltype(detail::synchronize(aut))
 Synchronize the transducer. More...
 
template<Automaton Aut>
bool is_synchronized_by (const Aut &aut, const word_t_of< Aut > &w)
 Whether w synchronizes automaton aut. More...
 
template<Automaton Aut>
bool is_synchronizing (const Aut &aut)
 Whether this automaton is synchronizing, i.e., has synchronizing words. More...
 
template<Automaton Aut>
word_t_of< Aut > synchronizing_word (const Aut &aut, const std::string &algo="greedy")
 Return a synchronizing word for aut using algo algo. More...
 
template<Automaton Aut, typename ExpSet >
Aut thompson (const context_t_of< Aut > &ctx, const ExpSet &rs, const typename ExpSet::value_t &r)
 Build a Thompson automaton from an expression. More...
 
template<Automaton Aut, typename ExpSet >
Aut thompson (const ExpSet &rs, const typename ExpSet::value_t &r)
 Build a Thompson automaton from an expression. More...
 
template<Automaton AutPtr>
std::ostream & tikz (const AutPtr &aut, std::ostream &out)
 Print automaton to TikZ format. More...
 
template<Automaton Aut>
Aut & eliminate_state_here (Aut &res, state_t_of< Aut > s=Aut::element_type::null_state())
 In place removal of state s from automaton res. More...
 
template<Automaton Aut>
auto eliminate_state (const Aut &aut, state_t_of< Aut > s=Aut::element_type::null_state()) -> fresh_automaton_t_of< Aut >
 A copy of automaton res without the state s. More...
 
template<Automaton Aut, typename Profiler , typename ExpSet = expressionset<context_t_of<Aut>>>
ExpSet::value_t to_expression (Aut &a, Profiler &profiler)
 
template<Automaton Aut, typename ExpSet = expressionset<context_t_of<Aut>>>
ExpSet::value_t to_expression_heuristic (const Aut &aut, vcsn::rat::identities ids, to_expression_heuristic_t algo)
 
template<Automaton Aut, typename ExpSet = expressionset<context_t_of<Aut>>>
ExpSet::value_t to_expression (const Aut &aut, vcsn::rat::identities ids, to_expression_heuristic_t algo)
 
template<Automaton Aut, typename ExpSet = expressionset<context_t_of<Aut>>>
ExpSet::value_t to_expression (const Aut &a, vcsn::rat::identities ids, const std::string &algo)
 
template<typename ExpressionSet >
ExpressionSet::value_t to_expression (const ExpressionSet &rs, const letter_class_t &letters, bool accept=true)
 An expression matching one letter in a letter class. More...
 
template<Automaton Aut>
auto to_spontaneous (const Aut &aut) -> std::enable_if_t<!context_t_of< Aut >::is_lao, decltype(make_mutable_automaton(make_context(oneset(), *aut->weightset())))>
 Convert to spontaneous automaton: change every transition's label to the empty word. More...
 
template<Automaton Aut>
Aut transpose (const transpose_automaton< Aut > &aut)
 The transpose of a transpose automaton is the original automaton. More...
 
template<Automaton Aut>
transpose_automaton< Aut > transpose (Aut aut)
 Transpose of an automaton. More...
 
template<typename PolynomialSet >
mutable_automaton< detail::free_context< context_t_of< PolynomialSet > > > trie (const PolynomialSet &ps, const typename PolynomialSet::value_t &p)
 Make a trie-like mutable_automaton for a finite series given as a polynomial. More...
 
template<typename PolynomialSet >
mutable_automaton< detail::free_context< context_t_of< PolynomialSet > > > cotrie (const PolynomialSet &ps, const typename PolynomialSet::value_t &p)
 Make a cotrie-like mutable_automaton for a finite series given as a polynomial. More...
 
template<typename PolynomialSet >
mutable_automaton< detail::free_context< context_t_of< PolynomialSet > > > trie (const PolynomialSet &ps, std::istream &is, const std::string &format="default")
 Make a trie-like mutable_automaton for a finite series read from a stream. More...
 
template<typename PolynomialSet >
mutable_automaton< detail::free_context< context_t_of< PolynomialSet > > > cotrie (const PolynomialSet &ps, std::istream &is, const std::string &format="default")
 Make a trie-like mutable_automaton for a finite series read from a stream. More...
 
template<typename... Ctx>
auto tuple_context (Ctx &&...ctx) -> context< tupleset< labelset_t_of< Ctx >... >, join_t< weightset_t_of< Ctx >... >>
 
template<typename... ExpansionSets>
auto tuple_expansionset (const ExpansionSets &...ess) -> rat::expansionset< decltype(tuple_expressionset(ess.expressionset()...))>
 
template<typename ValueSet , typename... ValueSets>
ValueSet::value_t tuple (const ValueSet &vs, const typename ValueSets::value_t &...v)
 
template<typename... ExpSets>
auto tuple_expressionset (const ExpSets &...rss) -> expressionset< decltype(tuple_context(rss.context()...))>
 
template<typename... PolynomialSets>
auto tuple_polynomialset (const PolynomialSets &...pss) -> polynomialset< decltype(tuple_context(pss.context()...))>
 
template<typename Context >
mutable_automaton< Context > u (const Context &ctx, unsigned n)
 The Brzozowski universal witness. More...
 
template<Automaton Aut>
Aut universal (const Aut &a)
 
template<Automaton Aut>
auto weight_series (const Aut &a) -> std::enable_if_t<!is_tropical< weightset_t_of< Aut >>::value, weight_t_of< Aut >>
 
template<Automaton Aut, typename Tag = auto_tag>
Aut & lweight_here (const weight_t_of< Aut > &w, Aut &res, Tag tag={})
 In place left-multiplication of an automaton by a weight. More...
 
template<Automaton Aut, typename Tag = auto_tag>
auto lweight (const weight_t_of< Aut > &w, const Aut &aut, Tag tag={}) -> fresh_automaton_t_of< Aut >
 Left-multiplication of an automaton by a weight. More...
 
template<typename ValueSet >
auto lweight (const ValueSet &rs, const weight_t_of< ValueSet > &w, const typename ValueSet::value_t &r) -> decltype(rs.lweight(w, r))
 
template<typename WeightSet , typename ExpSet >
expansionset< expressionset< context< labelset_t_of< ExpSet >, join_t< WeightSet, weightset_t_of< ExpSet > > > > > join_weightset_expansionset (const WeightSet &ws, const expansionset< ExpSet > &rs)
 
template<typename WeightSet , typename ExpSet >
expressionset< context< labelset_t_of< ExpSet >, join_t< WeightSet, weightset_t_of< ExpSet > > > > join_weightset_expressionset (const WeightSet &ws, const ExpSet &rs)
 Join between an expressionset and a weightset. More...
 
template<typename WeightSet , typename ExpSet >
auto join_weightset_polynomialset (const WeightSet &ws, const polynomialset< ExpSet > &ps)
 
template<Automaton Aut, typename Tag = auto_tag>
Aut & rweight_here (Aut &res, const weight_t_of< Aut > &w, Tag tag={})
 In place right-multiplication of an automaton by a weight. More...
 
template<Automaton Aut, typename Tag = auto_tag>
fresh_automaton_t_of< Aut > rweight (const Aut &aut, const weight_t_of< Aut > &w, Tag tag={})
 Right-multiplication of an automaton by a weight. More...
 
template<typename ValueSet >
ValueSet::value_t rweight (const ValueSet &rs, const typename ValueSet::value_t &r, const weight_t_of< ValueSet > &w)
 
template<Automaton Aut, typename ExpSet >
Aut zpc (const context_t_of< Aut > &ctx, const ExpSet &rs, const typename ExpSet::value_t &r, const std::string &algo="auto")
 Build a ZPC automaton from an expression. More...
 
template<>
char_letters::letter_t char_letters::special< char_letters::letter_t > ()
 
template<>
char_letters::word_t char_letters::special< char_letters::word_t > ()
 
template<typename Key , typename Compare , typename Allocator >
ATTRIBUTE_PURE bool has (const boost::container::flat_set< Key, Compare, Allocator > &s, const Key &e)
 Whether e is member of s. More...
 
template<>
string_letters::letter_t string_letters::special< string_letters::letter_t > ()
 
template<>
string_letters::word_t string_letters::special< string_letters::word_t > ()
 
template<typename ValueSet >
auto join (const ValueSet &vs) -> ValueSet
 The join of a single valueset. More...
 
template<typename ValueSet1 , typename ValueSet2 >
auto join (ValueSet1 vs1, ValueSet2 vs2) -> decltype(detail::join_(vs1, vs2, 0))
 The join of two valuesets. More...
 
template<typename ValueSet1 , typename ValueSet2 , typename ValueSet3 , typename... VSs>
auto join (ValueSet1 vs1, ValueSet2 vs2, ValueSet3 vs3, VSs &&...vs)
 The join of three (or more) valuesets. More...
 
template<typename Context >
mutable_automaton< Context > make_mutable_automaton (const Context &ctx)
 
template<typename Context >
auto make_nullable_automaton (const Context &ctx)
 
template<Automaton Aut>
auto make_partition_automaton (const fresh_automaton_t_of< Aut > &res, const Aut &input, const typename detail::partition_automaton_impl< Aut >::origins_t origins) -> partition_automaton_t< Aut >
 Build a partition_automaton. More...
 
template<Automaton Aut>
auto make_partition_automaton (const fresh_automaton_t_of< Aut > &res, const partition_automaton< Aut > &input, const typename detail::partition_automaton_impl< Aut >::origins_t origins) -> partition_automaton_t< Aut >
 Build a partition_automaton of a partition_automaton: smash into a single level partition_automaton. More...
 
template<Automaton Aut>
auto make_partition_automaton (const fresh_automaton_t_of< transpose_automaton< Aut >> &res, const transpose_automaton< Aut > &input, const typename detail::partition_automaton_impl< Aut >::origins_t origins) -> transpose_automaton< partition_automaton_t< Aut >>
 Build a partition_automaton of a transpose_automaton: smash into a transpose_automaton of a partition_automaton. More...
 
template<typename Context >
expansionset< expressionset< Context > > make_expansionset (const expressionset< Context > &es)
 
template<typename LabelSet , typename WeightSet >
auto make_expressionset (const context< LabelSet, WeightSet > &ctx, rat::identities ids={}) -> expressionset< context< LabelSet, WeightSet >>
 Shorthand to expressionset constructor. More...
 
template<typename Context >
auto make_expressionset (const expressionset< Context > &rs, rat::identities ids={}) -> expressionset< Context >
 Shorthand to expressionset constructor. More...
 
template<typename Ctx1 , typename Ctx2 >
auto meet (const expressionset< Ctx1 > &a, const expressionset< Ctx2 > &b) -> expressionset< meet_t< Ctx1, Ctx2 >>
 The meet of two expressionsets. More...
 
template<typename Context , typename RandomGenerator = std::default_random_engine>
expressionset< Context >::value_t random_label (const expressionset< Context > &rs, RandomGenerator &gen=RandomGenerator())
 Random label from expressionset: limited to a single label. More...
 
template<typename ExpSet >
ExpSet::value_t transpose (const ExpSet &rs, const typename ExpSet::value_t &v)
 An expression that denotes the transposition of v. More...
 
template<Automaton... Auts>
auto make_tuple_automaton (const Auts &...auts) -> tuple_automaton< Auts... >
 
template<typename LabelSet , typename WeightSet >
context< LabelSet, WeightSetmake_context (const LabelSet &ls, const WeightSet &ws)
 Shorthand to build a context. More...
 
template<typename ValueSet >
auto meet (const ValueSet &vs) -> ValueSet
 The meet of a single valueset. More...
 
template<typename ValueSet1 , typename ValueSet2 , typename ValueSet3 , typename... VSs>
auto meet (const ValueSet1 &vs1, const ValueSet2 &vs2, const ValueSet3 &vs3, const VSs &...vs) -> decltype(meet(meet(vs1, vs2), vs3, vs...))
 
template<typename LhsLabelSet , typename LhsWeightSet , typename RhsLabelSet , typename RhsWeightSet >
auto meet (const context< LhsLabelSet, LhsWeightSet > &a, const context< RhsLabelSet, RhsWeightSet > &b) -> context< meet_t< LhsLabelSet, RhsLabelSet >, join_t< LhsWeightSet, RhsWeightSet >>
 The meet of two contexts. More...
 
 VCSN_CTX_INSTANTIATE (ctx::lal_char_b)
 
 VCSN_CTX_INSTANTIATE (ctx::lal_char_br)
 
 VCSN_CTX_INSTANTIATE (ctx::lal_char_q)
 
 VCSN_CTX_INSTANTIATE (ctx::lal_char_zr)
 
 VCSN_CTX_INSTANTIATE (ctx::lal_char_zrr)
 
 VCSN_CTX_INSTANTIATE (ctx::law_char_br)
 
 VCSN_CTX_INSTANTIATE (ctx::law_char_zr)
 
 VCSN_CTX_INSTANTIATE (ctx::law_char_zrr)
 
template<typename T >
symbol sname ()
 
template<typename T >
symbol sname (T &)
 
template<typename... Args>
signature ssignature ()
 Static signature. More...
 
template<typename T >
symbol vname (T &t)
 
template<typename... Args>
signature vsignature (Args &&...args)
 The signature of (Args...). More...
 
template<typename LabelSet , typename RandomGenerator = std::default_random_engine>
LabelSet::value_t random_label (const LabelSet &ls, RandomGenerator &gen=RandomGenerator())
 Random label from general case such as letterset. More...
 
template<typename GenSet >
letterset< GenSet > meet (const letterset< GenSet > &lhs, const letterset< GenSet > &rhs)
 Compute the meet with another labelset. More...
 
template<typename GenSet >
nullableset< letterset< GenSet > > meet (const nullableset< letterset< GenSet >> &lhs, const nullableset< letterset< GenSet >> &rhs)
 Compute the meet with another labelset. More...
 
template<typename GenSet >
nullableset< letterset< GenSet > > meet (const letterset< GenSet > &lhs, const nullableset< letterset< GenSet >> &rhs)
 
template<typename GenSet >
nullableset< letterset< GenSet > > meet (const nullableset< letterset< GenSet >> &lhs, const letterset< GenSet > &rhs)
 
template<typename Lls , typename Rls >
nullableset< meet_t< Lls, Rls > > meet (const nullableset< Lls > &lhs, const nullableset< Rls > &rhs)
 
template<typename LabelSet , typename RandomGenerator = std::default_random_engine>
nullableset< LabelSet >::value_t random_label (const nullableset< LabelSet > &ls, RandomGenerator &gen=RandomGenerator())
 Random label from nullableset. More...
 
oneset meet (const oneset &, const oneset &)
 The meet of two labelsets. More...
 
template<typename RandomGenerator = std::default_random_engine>
oneset::value_t random_label (const oneset &ls, RandomGenerator &=RandomGenerator())
 Random label from oneset. More...
 
template<typename... LabelSet, typename RandomGenerator = std::default_random_engine>
tupleset< LabelSet... >::value_t random_label (const tupleset< LabelSet... > &ls, RandomGenerator &gen=RandomGenerator())
 Random label from tupleset. More...
 
template<typename... LabelSet, size_t... I, typename RandomGenerator = std::default_random_engine>
tupleset< LabelSet... >::value_t random_label_ (const tupleset< LabelSet... > &ls, RandomGenerator &gen, detail::index_sequence< I... >)
 Implementation detail for random label from tupleset. More...
 
template<typename GenSet >
wordset< GenSet > meet (const wordset< GenSet > &lhs, const wordset< GenSet > &rhs)
 Compute the meet with another alphabet. More...
 
template<typename GenSet , typename RandomGenerator = std::default_random_engine>
wordset< GenSet >::value_t random_label (const wordset< GenSet > &ls, RandomGenerator &gen=RandomGenerator())
 Random label from wordset. More...
 
template<typename Container , typename = typename Container::value_type>
Container set_difference (const Container &s1, const Container &s2)
 The set of members of s1 that are not members of s2. More...
 
template<typename Container , typename = typename Container::value_type>
Container set_intersection (const Container &s1, const Container &s2)
 The intersection of two sets. More...
 
template<typename Container >
bool same_domain (const Container &x, const Container &y)
 Check that two associative containers have the same keys. More...
 
template<typename Container , typename = typename Container::value_type>
Container set_union (const Container &s1, const Container &s2)
 The union of two sets. More...
 
template<typename Map , typename Key >
auto has (const Map &s, const Key &e) -> decltype(s.find(e)!=std::end(s))
 Whether e is in s. More...
 
template<typename Cont , typename Pred >
container_filter_range< Cont, Pred > make_container_filter_range (const Cont &cont, Pred pred)
 
template<typename... Sequences>
cross_sequences< Sequences... > cross (Sequences &&...seqs)
 
template<typename... Sequences>
cross_sequences< Sequences... > cross_tuple (const std::tuple< Sequences... > &seqs)
 
template<typename T , typename Allocator = std::allocator<T>>
ATTRIBUTE_PURE bool has (const std::deque< T, Allocator > &s, const T &e)
 Whether e is member of s. More...
 
std::string to_string (direction d)
 Conversion to string. More...
 
std::istream & operator>> (std::istream &is, direction &d)
 Parsing. More...
 
std::ostream & operator<< (std::ostream &os, direction d)
 Pretty-printing. More...
 
template<typename Container >
dynamic_bitset make_dynamic_bitset (const Container &c, size_t size)
 
bool operator< (empty_t, empty_t)
 
bool operator== (empty_t, empty_t)
 
std::ostream & str_escape (std::ostream &os, const std::string &str, const char *special=nullptr)
 Output a string, escaping special characters. More...
 
template<typename T >
std::ostream & str_escape (std::ostream &os, const std::vector< T > &s, const char *special=nullptr)
 A container of letters. More...
 
std::ostream & str_escape (std::ostream &os, int c, const char *special=nullptr)
 Output a character, escaping special characters. More...
 
std::ostream & str_escape (std::ostream &os, char c, const char *special=nullptr)
 Output a character, escaping special characters. More...
 
template<typename T >
std::string str_escape (T &&s, const char *special=nullptr)
 
std::ostream & operator<< (std::ostream &o, const file_library &l)
 Print l on o. More...
 
template<typename Range , typename Filter >
auto filter (Range &&r, Filter f, decltype(f(*std::begin(r)), void())*=nullptr)
 Similar to boost::adaptors::filter, but ensures that the range is kept alive. More...
 
std::string to_string (format i)
 Wrapper around operator<<. More...
 
std::istream & operator>> (std::istream &is, format &i)
 Read from string form. More...
 
std::ostream & operator<< (std::ostream &os, format i)
 Output in string form. More...
 
void hash_combine_hash (std::size_t &seed, size_t h)
 
template<typename T >
void hash_combine (std::size_t &seed, const T &v)
 
std::ostream & incindent (std::ostream &o)
 Increment the indentation. More...
 
std::ostream & decindent (std::ostream &o)
 Decrement the indentation. More...
 
std::ostream & resetindent (std::ostream &o)
 Reset the indentation. More...
 
std::ostream & indent (std::ostream &o)
 Set the indentation. More...
 
std::ostream & iendl (std::ostream &o)
 Print an end of line, then set the indentation. More...
 
std::ostream & incendl (std::ostream &o)
 Increment the indentation, print an end of line, and set the indentation. More...
 
std::ostream & decendl (std::ostream &o)
 Decrement the indentation, print an end of line, and set the indentation. More...
 
template<typename T , typename U >
bool has (std::initializer_list< T > s, const U &e)
 Whether e is in s. More...
 
template<typename Key , typename Value , typename Compare , typename Alloc >
bool has (const std::map< Key, Value, Compare, Alloc > &s, const Key &e)
 Whether e is in s. More...
 
template<typename Key , typename Value , typename Comp , typename Alloc >
std::set< typename std::map< Key, Value, Comp, Alloc >::mapped_type > image (const std::map< Key, Value, Comp, Alloc > &m)
 The set of values of a map. More...
 
template<typename SharedPtr , typename... Args>
SharedPtr make_shared_ptr (Args &&...args)
 Same as std::make_shared, but parameterized by the shared_ptr type, not the (pointed to) element_type. More...
 
unsigned address (const void *t)
 Name pointers, to make them easier to read. More...
 
template<typename T >
unsigned address (T *t)
 
template<typename T >
unsigned address (const T &t)
 
template<typename T >
auto make_unordered_pair (T &&e1, T &&e2)
 
path absolute (const path &p)
 
bool exists (const path &p)
 
std::ostream & operator<< (std::ostream &o, const path &p)
 Dump p on o. More...
 
template<typename T , typename Container >
ATTRIBUTE_PURE bool has (const std::queue< T, Container > &s, const T &e)
 Whether e is member of s. More...
 
template<typename... Args>
ATTRIBUTE_NORETURN void raise (Args &&...args)
 Raise a runtime_error with the concatenation of args as message. More...
 
template<typename Bool , typename... Args>
void require (Bool b, Args &&...args)
 If b is not verified, raise an error with args as message. More...
 
template<typename WeightSet >
ATTRIBUTE_NORETURN void raise_not_starrable (const WeightSet &ws, const typename WeightSet::value_t &w)
 This value is not starrable. More...
 
std::mt19937 & make_random_engine ()
 Generate a unique random device. More...
 
template<typename RandomGenerator = std::default_random_engine>
static bool choose_map (const std::vector< float > &map, RandomGenerator &gen=RandomGenerator())
 Choose whether to pick an element from a map or not. More...
 
template<typename RandomGenerator >
random_selector< RandomGenerator > make_random_selector (RandomGenerator &g)
 
template<typename T , typename Compare , typename Alloc >
bool has (const std::set< T, Compare, Alloc > &s, const T &e) ATTRIBUTE_PURE
 Whether e is member of s. More...
 
template<typename T , typename Compare , typename Alloc >
std::set< std::set< T, Compare, Alloc > > intersection_closure (std::set< std::set< T, Compare, Alloc >> pset)
 The set of all the intersections of the sets in pset. More...
 
template<typename T , typename Compare , typename Alloc >
std::ostream & print (const std::set< T, Compare, Alloc > &set, std::ostream &o)
 Print with a separator. Meant to help debugging. More...
 
template<typename Container >
bool subset (const Container &set1, const Container &set2) ATTRIBUTE_PURE
 Whether set1set2. More...
 
std::ostream & operator<< (std::ostream &os, const signature &sig)
 Output a string, escaping special characters. More...
 
template<typename Key , typename Value >
bool has (const sparse_map< Key, Value > &s, Key k)
 
template<typename T >
bool has (const sparse_set< T > &s, T e)
 
std::string bracketed (std::istream &i, char lbracket, char rbracket)
 Extract the string which is here between lbracket and rbracket. More...
 
template<typename ValueSet , typename... Args>
auto conv (const ValueSet &vs, const std::string &str, Args &&...args) -> decltype(vs.conv(std::declval< std::istream & >(), std::forward< Args >(args)...))
 Parse str via vs.conv. More...
 
char eat (std::istream &is, char c)
 Check lookahead character and advance. More...
 
const std::string & eat (std::istream &is, const std::string &s)
 Check lookahead string and advance. More...
 
template<typename... Args>
ATTRIBUTE_NORETURN void fail_reading (std::istream &is, Args &&...args)
 Throw an exception after failing to read from is. More...
 
char get_char (std::istream &i)
 Read a single char, with possible -escape support. More...
 
std::string get_file_contents (const std::string &file)
 Return the contents of file. More...
 
std::shared_ptr< std::istream > open_input_file (const std::string &file)
 Open file for reading and return its autoclosing stream. More...
 
std::shared_ptr< std::ostream > open_output_file (const std::string &file)
 Open file for writing and return its autoclosing stream. More...
 
void skip_space (std::istream &is)
 Ignore spaces. More...
 
std::string operator+ (symbol l, const char *r)
 
std::string operator+ (const char *l, symbol r)
 
std::string operator+ (symbol l, const std::string &r)
 
std::string operator+ (const std::string &l, symbol r)
 
template<typename ValueSet , typename Value = typename ValueSet::value_t, typename... Args>
auto to_string (const ValueSet &vs, const Value &v, Args &&...args) -> std::string
 Format v via vs.print. More...
 
std::ostream & operator<< (std::ostream &o, const to &t)
 
template<bool... B>
constexpr bool any_ ()
 Static evaluation of the 'or' of the template parameters. More...
 
template<bool... B>
constexpr bool all_ ()
 
template<typename... Bool>
bool all (Bool &&...values)
 Whether all the values evaluate as true. More...
 
template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >
size_t collision_count (const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &m)
 Sum of bucket sizes. More...
 
template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >
bool has (const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &m, const Key &k)
 Whether e is member of m. More...
 
template<typename Key , typename Hash , typename KeyEqual , typename Alloc >
bool has (const std::unordered_set< Key, Hash, KeyEqual, Alloc > &s, const Key &k)
 Whether e is member of s. More...
 
template<typename Key , typename Hash , typename KeyEqual , typename Alloc >
std::unordered_set< Key, Hash, KeyEqual, Alloc > set_intersection (const std::unordered_set< Key, Hash, KeyEqual, Alloc > &s1, const std::unordered_set< Key, Hash, KeyEqual, Alloc > &s2)
 Intersection of s1 and s2. More...
 
template<typename T , typename Alloc >
ATTRIBUTE_PURE bool has (const std::vector< T, Alloc > &s, const T &e)
 Whether e is member of s. More...
 
template<typename Label , typename Weight >
auto label_of (const welement< Label, Weight > &m) -> decltype(m.label())
 The label of a welement. More...
 
template<typename Label , typename Weight >
auto weight_of (const welement< Label, Weight > &m) -> decltype(m.weight())
 The weight of a welement. More...
 
template<typename Label , typename Weight >
void weight_set (welement< Label, Weight > &m, const Weight &w)
 Set the weight of a welement. More...
 
template<typename Label , typename Weight >
const Label & label_of (const std::pair< Label, Weight > &m)
 The label of a pair (label, weight). More...
 
template<typename Label , typename Weight >
const Weight & weight_of (const std::pair< Label, Weight > &m)
 The weight of a pair (label, weight). More...
 
template<typename Label , typename Weight >
Label & label_of (std::pair< Label, Weight > &m)
 The label of a pair (label, weight). More...
 
template<typename Label , typename Weight >
void weight_set (std::pair< Label, Weight > &m, const Weight &w)
 Set the weight of a pair (label, weight). More...
 
std::string to_string (wet_kind_t k)
 String version of a wet kind. More...
 
std::ostream & operator<< (std::ostream &o, const iomanipulator &g)
 Launch the iomanipulator action on o. More...
 
template<typename Dereference = as_pair, typename... Maps>
zipped_maps< Dereference, Maps... > zip_maps (Maps &&...maps)
 
template<typename Dereference = as_pair, typename... Maps>
zipped_maps< Dereference, Maps... > zip_map_tuple (const std::tuple< Maps... > &maps)
 
template<typename... Sequences>
zip_sequences< Sequences... > zip (Sequences &&...seqs)
 
template<typename... Sequences>
zip_sequences< Sequences... > zip_tuple (const std::tuple< Sequences... > &seqs)
 
template<typename... Sequences>
zip_sequences_padded< zip_sequences< Sequences... > > zip_with_padding (const std::tuple< typename Sequences::value_type... > &pad, const Sequences &...seq)
 
template<typename LabelSet >
auto label_is_zero (const LabelSet &ls, const typename LabelSet::value_t *l) -> decltype(ls.is_zero(l), bool())
 
template<typename LabelSet >
bool label_is_zero (const LabelSet &,...) ATTRIBUTE_CONST
 

Variables

return v
 
return exp min
 
 else
 
return res
 
std::ostream cnull {nullptr}
 An narrow-char stream that discards the output. More...
 
std::wostream wcnull {nullptr}
 An wide-char stream that discards the output. More...
 

Typedef Documentation

template<typename ValueSet >
using vcsn::add_mem_fn_t = typedef decltype(std::declval<ValueSet>() .add(std::declval<typename ValueSet::value_t>(), std::declval<typename ValueSet::value_t>()))

The type of the add member function in valuesets.

Definition at line 332 of file multiply.hh.

Definition at line 48 of file fwd.hh.

template<typename T >
using vcsn::base_t = typedef std::remove_cv_t<std::remove_reference_t<T>>

T without reference or const/volatile qualifiers.

Definition at line 13 of file traits.hh.

template<bool B>
using vcsn::bool_constant = typedef std::integral_constant<bool, B>

Definition at line 12 of file type_traits.hh.

template<Automaton Aut>
using vcsn::codeterminized_automaton = typedef transpose_automaton<determinized_automaton <decltype(transpose(std::declval<Aut>())), wet_kind_t::bitset>>

The type of the codeterminized automaton.

Use decltype on transpose because transpose(transpose(a)) returns a.

Definition at line 25 of file minimize-brzozowski.hh.

template<bool Lazy, Automaton Lhs, Automaton Rhs>
using vcsn::compose_automaton = typedef std::shared_ptr<detail::compose_automaton_impl<Lazy, Lhs, Rhs>>

A compose automaton as a shared pointer.

Definition at line 447 of file compose.hh.

template<typename ValueSet >
using vcsn::context_t_of = typedef typename detail:: context_t_of_impl<base_t<ValueSet>>::type

Definition at line 61 of file traits.hh.

template<Automaton Aut>
using vcsn::delay_automaton = typedef std::shared_ptr<detail::delay_automaton_impl<Aut>>

An automaton wrapper that presents the delay automaton.

Definition at line 27 of file fwd.hh.

template<typename ExpSet >
using vcsn::derived_term_automaton = typedef std::shared_ptr<detail::derived_term_automaton_impl<ExpSet>>

A derived-term automaton as a shared pointer.

Definition at line 315 of file derived-term.hh.

template<Automaton Aut, wet_kind_t Kind, bool Lazy = false>
using vcsn::determinized_automaton = typedef std::shared_ptr<detail::determinized_automaton_impl<Aut, Kind, Lazy>>

A determinized automaton as a shared pointer.

Definition at line 243 of file determinize.hh.

using vcsn::dynamic_bitset = typedef boost::dynamic_bitset<>

Definition at line 35 of file dynamic_bitset.hh.

template<typename ExpSet >
using vcsn::expansionset = typedef rat::expansionset<ExpSet>

Definition at line 208 of file fwd.hh.

template<Automaton Aut>
using vcsn::expression_automaton = typedef std::shared_ptr<detail::expression_automaton_impl<Aut>>

An expression automaton as a shared pointer.

Definition at line 61 of file fwd.hh.

template<typename Context >
using vcsn::expressionset = typedef weightset_mixin<rat::expressionset_impl<Context>>

Definition at line 205 of file fwd.hh.

Definition at line 49 of file fwd.hh.

template<Automaton Aut, bool Trans = false>
using vcsn::filter_automaton = typedef std::shared_ptr<detail::filter_automaton_impl<Aut, Trans>>

Definition at line 296 of file filter.hh.

template<std::size_t Tape, Automaton Aut>
using vcsn::focus_automaton = typedef std::shared_ptr<detail::focus_automaton_impl<Tape, Aut>>

A focus automaton as a shared pointer.

Definition at line 42 of file fwd.hh.

template<typename Aut , typename Context = context_t_of<Aut>>
using vcsn::fresh_automaton_t_of = typedef typename Aut::element_type::template fresh_automaton_t<Context>

Given an automaton type, the type of its copies.

Strips most decorators, with the notable exception of transpose_automaton: copies of transposed automata are transposed automata, but with all other kinds of decorations removed. This allows a simple implementation of "co-algorithms": transpose the input automaton, create a fresh copy (which is therefore transposed), process it, and then return its transposition, i.e., a forward automaton.

Definition at line 82 of file traits.hh.

template<typename ValueSet >
using vcsn::has_add_mem_fn = typedef detail::detect<ValueSet, add_mem_fn_t>

Whether ValueSet features an add() member function.

Definition at line 336 of file multiply.hh.

template<Automaton Aut>
using vcsn::insplit_automaton = typedef detail::insplit_automaton<Aut>

An insplit automaton as a shared pointer.

Definition at line 291 of file insplit.hh.

template<typename... ValueSets>
using vcsn::join_t = typedef decltype(join(std::declval<ValueSets>()...))

The type of the join of the ValueSets.

Definition at line 78 of file join.hh.

template<typename ValueSet >
using vcsn::label_t_of = typedef typename detail:: label_t_of_impl<base_t<ValueSet>>::type

Definition at line 62 of file traits.hh.

template<typename ValueSet >
using vcsn::labelset_t_of = typedef typename detail:: labelset_t_of_impl<base_t<ValueSet>>::type

Definition at line 63 of file traits.hh.

template<Automaton Aut>
using vcsn::lazy_proper_automaton = typedef std::shared_ptr<detail::lazy_proper_automaton_impl<Aut>>

Definition at line 204 of file epsilon-remover-lazy.hh.

using vcsn::letter_class_t = typedef std::set<std::pair<std::string, std::string>>

A set of letter ranges.

Definition at line 111 of file fwd.hh.

template<typename ValueSet >
using vcsn::letter_t_of = typedef typename labelset_t_of<base_t<ValueSet>>::letter_t

Definition at line 86 of file traits.hh.

Definition at line 50 of file fwd.hh.

template<typename... ValueSets>
using vcsn::meet_t = typedef decltype(meet(std::declval<ValueSets>()...))

Definition at line 158 of file context.hh.

template<typename Context >
using vcsn::mutable_automaton = typedef std::shared_ptr<detail::mutable_automaton_impl<Context>>

Definition at line 25 of file fwd.hh.

template<Automaton Aut>
using vcsn::name_automaton = typedef std::shared_ptr<detail::name_automaton_impl<Aut>>

Definition at line 35 of file fwd.hh.

Definition at line 51 of file fwd.hh.

template<Automaton Aut>
using vcsn::pair_automaton = typedef std::shared_ptr<detail::pair_automaton_impl<Aut>>

Definition at line 245 of file pair.hh.

template<Automaton Aut>
using vcsn::partial_identity_context_t_of = typedef typename detail::partial_identity_context<Aut>::context_t

Definition at line 35 of file partial-identity.hh.

template<Automaton Aut>
using vcsn::partition_automaton = typedef std::shared_ptr<detail::partition_automaton_impl<Aut>>

A partition automaton as a shared pointer.

Definition at line 143 of file partition-automaton.hh.

template<Automaton Aut>
using vcsn::partition_automaton_t = typedef typename detail::partition_automaton_t_impl<Aut>::type

The return type when calling quotient on Aut.

Definition at line 202 of file partition-automaton.hh.

template<typename Aut >
using vcsn::path_t_of = typedef std::vector<transition_t_of<Aut>>

A list of transitions representing a path.

Transitions are listed from source (front) to destination (back). The destination of each transition is the source of the following one in the vector. By definition, none of these transitions can be null_transition or this path would be considered ill-formed.

Definition at line 27 of file automaton.hh.

template<Automaton Aut>
using vcsn::permutation_automaton = typedef std::shared_ptr<detail::permutation_automaton_impl<Aut>>

A permutation automaton as a shared pointer.

Definition at line 48 of file fwd.hh.

template<typename Context , wet_kind_t Kind = detail::wet_kind<labelset_t_of<Context>, weightset_t_of<Context>>()>
using vcsn::polynomialset = typedef weightset_mixin<detail::polynomialset_impl<Context, Kind>>

Definition at line 63 of file fwd.hh.

template<typename Aut >
using vcsn::predecessors_t_of = typedef std::vector<transition_t_of<Aut>>

A state-indexed vector of predecessor transitions from the path path.

For each state s, res[s] is null_transition if it is not part of path (or it is its beginning), or res[s] is the transition index that points to the incoming transition to s in path.

Definition at line 18 of file automaton.hh.

Definition at line 52 of file fwd.hh.

Definition at line 53 of file fwd.hh.

template<Automaton Aut>
using vcsn::quotient_t = typedef partition_automaton_t<Aut>

The return type when calling quotient on Aut.

Definition at line 119 of file quotient.hh.

Definition at line 54 of file fwd.hh.

Definition at line 55 of file fwd.hh.

template<Automaton Aut>
using vcsn::scc_automaton = typedef std::shared_ptr<detail::scc_automaton_impl<Aut>>

Definition at line 688 of file scc.hh.

template<typename ValueSet >
using vcsn::state_t_of = typedef typename detail:: state_t_of_impl<base_t<ValueSet>>::type

Definition at line 64 of file traits.hh.

template<Automaton Aut>
using vcsn::states_t = typedef std::unordered_set<state_t_of<Aut>>

Definition at line 19 of file accessible.hh.

using vcsn::symbol = typedef boost::flyweight<std::string, boost::flyweights::no_tracking, boost::flyweights::intermodule_holder>

An internalized string.

We do use different modules, since we dlopen plugins. For a while, we had the illusion that it work properly, but that's only because we were using the default operator< which actually compares the strings, not the address of the symbols. So we did have synonymous symbols, which the code gracefully accepted.

Play it safe and make our symbols unique.

Definition at line 23 of file symbol.hh.

template<Automaton Aut>
using vcsn::synchronized_automaton = typedef std::shared_ptr<detail::synchronized_automaton_impl<Aut>>

An automaton wrapper that presents the synchronized automaton.

Definition at line 91 of file fwd.hh.

template<typename ValueSet >
using vcsn::transition_t_of = typedef typename detail:: transition_t_of_impl<base_t<ValueSet>>::type

Definition at line 65 of file traits.hh.

template<Automaton Aut>
using vcsn::transpose_automaton = typedef std::shared_ptr<detail::transpose_automaton_impl<Aut>>

An automaton wrapper that presents the transposed automaton.

Definition at line 108 of file fwd.hh.

template<Automaton... Auts>
using vcsn::tuple_automaton = typedef std::shared_ptr<detail::tuple_automaton_impl<Auts...>>

A tuple automaton as a shared pointer.

Definition at line 293 of file tuple-automaton.hh.

template<size_t I, typename T >
using vcsn::tuple_element_t = typedef typename std::tuple_element<I, T>::type

C++14.

Definition at line 14 of file tuple.hh.

template<typename... LabelSets>
using vcsn::tupleset = typedef weightset_mixin<detail::tupleset_impl<LabelSets...>>

Definition at line 27 of file fwd.hh.

template<typename ValueSet >
using vcsn::weight_t_of = typedef typename detail:: weight_t_of_impl<base_t<ValueSet>>::type

Definition at line 66 of file traits.hh.

template<typename ValueSet >
using vcsn::weightset_t_of = typedef typename detail:: weightset_t_of_impl<base_t<ValueSet>>::type

Definition at line 67 of file traits.hh.

template<typename Key , typename Value , wet_kind_t Kind = detail::wet_kind<Key, Value>(), typename Compare = std::less<Key>, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using vcsn::wet = typedef detail::wet_impl<Kind, Key, Value, Compare, Hash, KeyEqual>

Given Key/Value types, the appropriate weighted set type.

Definition at line 852 of file wet.hh.

template<typename Context , wet_kind_t Kind = detail::wet_kind<labelset_t_of<Context>, weightset_t_of<Context>>()>
using vcsn::wet_of = typedef wet<label_t_of<Context>, weight_t_of<Context>, Kind, vcsn::less<labelset_t_of<Context>>, vcsn::hash<labelset_t_of<Context>>, vcsn::equal_to<labelset_t_of<Context>>>

The corresponding wet for a LabelSet -> WeightSet context.

Definition at line 863 of file wet.hh.

template<typename ValueSet >
using vcsn::word_t_of = typedef typename labelset_t_of<base_t<ValueSet>>::word_t

Definition at line 90 of file traits.hh.

Definition at line 56 of file fwd.hh.

Definition at line 57 of file fwd.hh.

Enumeration Type Documentation

enum vcsn::direction
strong

Orientation.

Enumerator
forward 

Looking downstream.

backward 

Looking upstream.

Definition at line 11 of file direction.hh.

enum vcsn::scc_algo_t
strong
Enumerator
auto_ 
dijkstra 
tarjan_iterative 
tarjan_recursive 
kosaraju 

Definition at line 506 of file scc.hh.

Enumerator
ABSVAL 

valid iff proper succeeds on the "absolute value" of the automaton

NON_STARRABLE 
STARRABLE 

always valid.

TOPS 

valid iff proper succeeds.

Definition at line 5 of file star-status.hh.

Enumerator
best 
delgado 
delgado_label 
naive 

Definition at line 511 of file to-expression.hh.

enum vcsn::wet_kind_t
strong

Different implementations of wets.

Enumerator
bitset 

Request the bitset implementation (bool weights).

map 

Request the map implementation.

set 

Request the set implementation (bool weights).

unordered_map 

Request the unordered_map implementation.

Definition at line 197 of file wet.hh.

Function Documentation

path vcsn::absolute ( const path p)

Definition at line 104 of file path.cc.

References vcsn::path::cwd(), and vcsn::path::is_absolute().

Referenced by vcsn::file_library::push_back(), vcsn::file_library::push_current_directory(), and vcsn::file_library::push_front().

Here is the call graph for this function:

template<Automaton Aut>
filter_automaton<Aut> vcsn::accessible ( const Aut &  a)

Accessible part of an automaton.

Definition at line 134 of file accessible.hh.

References accessible_states(), and filter().

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::ldivide(), vcsn::ctx::detail::register_functions(), and useful_states().

Here is the call graph for this function:

template<Automaton Aut>
states_t<Aut> vcsn::accessible_states ( const Aut &  aut,
bool  strict = true 
)

The set of accessible states, including pre(), and possibly post().

Parameters
autthe automaton.
strictwhether to evaluate lazy states.

Definition at line 27 of file accessible.hh.

References vcsn::detail::all_out(), and res.

Referenced by accessible(), coaccessible_states(), num_accessible_states(), suffix_here(), and useful_states().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
auto vcsn::add ( const Aut1 &  lhs,
const Aut2 &  rhs,
deterministic_tag   
)

Definition at line 71 of file add.hh.

References determinize(), and vcsn::detail::join_automata().

Referenced by vcsn::dyn::add(), vcsn::dyn::detail::add_expansion(), vcsn::dyn::detail::add_expression(), and info().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2, typename Tag = general_tag>
auto vcsn::add ( const Aut1 &  lhs,
const Aut2 &  rhs,
Tag  tag = {} 
) -> decltype(join_automata(lhs, rhs))

The sum of two automata.

Parameters
lhsthe first automaton.
rhsthe second automaton.
tagwhether to use constructs for standard automata.

Definition at line 108 of file add.hh.

template<typename ValueSet >
ValueSet::value_t vcsn::add ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Sums of values.

Definition at line 146 of file add.hh.

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::add_here ( Aut1 &  res,
const Aut2 &  b,
standard_tag   
)

Merge transitions of b into those of res.

Precondition
The context of res must include that of b.
res and b must be standard.

Definition at line 28 of file add.hh.

References vcsn::detail::all_transitions(), vcsn::detail::front(), vcsn::detail::initial_transitions(), is_standard(), require(), and res.

Referenced by vcsn::rat::expansionset< expressionset_t >::add(), and add_here().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
auto vcsn::add_here ( Aut1 &  res,
const Aut2 &  b,
deterministic_tag   
)

Definition at line 62 of file add.hh.

References add_here(), determinize(), and res.

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::add_here ( Aut1 &  res,
const Aut2 &  b,
general_tag   
)

Merge transitions of b into those of res.

Precondition
Aut2 <: Aut1.

Definition at line 95 of file add.hh.

References copy_into(), and res.

Here is the call graph for this function:

unsigned vcsn::address ( const void *  t)
inline

Name pointers, to make them easier to read.

Definition at line 21 of file memory.hh.

Referenced by address(), and vcsn::rat::printer< ExpSet >::print_().

template<typename T >
unsigned vcsn::address ( T *  t)

Definition at line 31 of file memory.hh.

References address().

Here is the call graph for this function:

template<typename T >
unsigned vcsn::address ( const T &  t)

Definition at line 37 of file memory.hh.

References address().

Here is the call graph for this function:

template<bool... B>
constexpr bool vcsn::all_ ( )

Definition at line 439 of file tuple.hh.

template<Automaton Aut>
std::vector<std::vector<weight_t_of<Aut> > > vcsn::all_distances ( const Aut &  aut)

Definition at line 107 of file distance.hh.

References vcsn::detail::all_transitions(), res, and vcsn::detail::states_size().

Referenced by vcsn::detail::epsilon_remover_distance< Aut, has_one >::epsilon_remover_distance().

Here is the call graph for this function:

template<Automaton Aut>
word_t_of<Aut> vcsn::ambiguous_word ( const Aut &  aut)

Definition at line 110 of file is-ambiguous.hh.

References is_ambiguous(), and require().

Referenced by vcsn::dyn::ambiguous_word().

Here is the call graph for this function:

template<bool... B>
constexpr bool vcsn::any_ ( )

Static evaluation of the 'or' of the template parameters.

Definition at line 432 of file tuple.hh.

template<Automaton Aut1, Automaton Aut2>
auto vcsn::are_equivalent ( const Aut1 &  a1,
const Aut2 &  a2 
) -> std::enable_if_t<(std::is_same<weightset_t_of<Aut1>, b>::value && std::is_same<weightset_t_of<Aut2>, b>::value), bool>

Check equivalence between Boolean automata on a free labelset.

Check equivalence between automata on fields, or Z.

Definition at line 27 of file are-equivalent.hh.

References difference(), is_useless(), and realtime().

Referenced by are_equivalent().

Here is the call graph for this function:

template<typename ExpSet1 , typename ExpSet2 >
auto vcsn::are_equivalent ( const ExpSet1 &  rs1,
const typename ExpSet1::value_t  r1,
const ExpSet2 &  rs2,
const typename ExpSet2::value_t  r2 
) -> bool

Check equivalence between two expressions.

Definition at line 83 of file are-equivalent.hh.

References are_equivalent(), derived_term(), and strip().

Referenced by vcsn::dyn::are_equivalent(), and vcsn::dyn::detail::are_equivalent_expression().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
bool vcsn::are_isomorphic ( const Aut1 &  a1,
const Aut2 &  a2 
)

Definition at line 694 of file are-isomorphic.hh.

Referenced by vcsn::ctx::detail::register_functions().

template<Automaton Aut>
fresh_automaton_t_of<Aut> vcsn::aut_of_component ( const detail::component_t< Aut > &  com,
const Aut &  aut 
)

Generate a subautomaton corresponding to an SCC.

Definition at line 573 of file scc.hh.

References has(), make_fresh_automaton(), vcsn::detail::out(), and res.

Referenced by is_cycle_ambiguous().

Here is the call graph for this function:

std::string vcsn::bracketed ( std::istream &  i,
char  lbracket,
char  rbracket 
)

Extract the string which is here between lbracket and rbracket.

Support nested lbracket/rbracket.

Definition at line 17 of file stream.cc.

References str_escape().

Referenced by vcsn::detail::polynomialset_impl< Context, Kind >::conv_weight().

Here is the call graph for this function:

template<typename Ctx >
mutable_automaton<Ctx> vcsn::cerny ( const Ctx &  ctx,
unsigned  num_states 
)

Cerny automata are automata whose synchronizing word length is always (n - 1)^2, the upper bound of the Cerny's conjecture.

Their transition function d(q, l) is defined by:

  • (q + 1) % n if l == a
  • q if l != a and q != n - 1
  • 0 if l != a and q == n - 1

Definition at line 25 of file cerny.hh.

References vcsn::detail::ctx, require(), and res.

Referenced by vcsn::dyn::cerny(), and vcsn::ctx::detail::register_functions_is_free().

Here is the call graph for this function:

Definition at line 268 of file char.hh.

Definition at line 276 of file char.hh.

template<typename RandomGenerator = std::default_random_engine>
static bool vcsn::choose_map ( const std::vector< float > &  map,
RandomGenerator &  gen = RandomGenerator() 
)
static

Choose whether to pick an element from a map or not.

To do so we apply a Bernoulli distribution on the sum of the probabilities of the map.

Definition at line 17 of file random.hh.

Referenced by vcsn::detail::random_weight_base< zmin, RandomGenerator >::print_random_weight_().

template<Automaton Aut>
filter_automaton<Aut> vcsn::coaccessible ( const Aut &  a)

Coaccessible part of an automaton.

Definition at line 142 of file accessible.hh.

References coaccessible_states(), and filter().

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::complement(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::conjunction(), vcsn::detail::is_ambiguous_impl< Aut >::operator()(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::rdivide(), vcsn::ctx::detail::register_functions(), and useful_states().

Here is the call graph for this function:

template<Automaton Aut>
states_t<Aut> vcsn::coaccessible_states ( const Aut &  a,
bool  strict = true 
)

The set of coaccessible states, including post(), and possibly pre().

Parameters
athe automaton.
strictwhether to evaluate lazy states.

Definition at line 64 of file accessible.hh.

References accessible_states(), and transpose().

Referenced by coaccessible(), is_partial_identity(), vcsn::detail::is_ambiguous_impl< Aut >::operator()(), and useful_states().

Here is the call graph for this function:

template<Automaton Aut, typename Tag = auto_tag>
auto vcsn::codeterminize ( const Aut &  aut,
Tag  tag = {} 
)

Definition at line 371 of file determinize.hh.

Referenced by minimize().

template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >
size_t vcsn::collision_count ( const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &  m)

Sum of bucket sizes.

Definition at line 12 of file unordered_map.hh.

References res.

template<Automaton Aut, typename Tag = auto_tag>
auto vcsn::cominimize ( const Aut &  a,
Tag  tag = {} 
) -> decltype(transpose(minimize(transpose(a), tag)))

Cominimization.

Definition at line 122 of file minimize.hh.

template<Automaton Aut>
auto vcsn::complement ( const Aut &  aut) -> decltype(copy(aut))

Definition at line 48 of file complement.hh.

References complement_here(), copy(), and res.

Referenced by difference(), and info().

Here is the call graph for this function:

template<Automaton Aut>
void vcsn::complement_here ( Aut &  aut)

Definition at line 21 of file complement.hh.

References vcsn::detail::final_transitions(), has(), is_complete(), is_deterministic(), and require().

Referenced by complement().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::complete ( const Aut &  aut) -> decltype(::vcsn::copy(aut))

A complete copy of aut.

Definition at line 65 of file complete.hh.

References complete_here(), copy(), and res.

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::complement(), difference(), vcsn::detail::universal_impl< Aut >::operator()(), and vcsn::ctx::detail::register_functions_is_free().

Here is the call graph for this function:

template<Automaton Aut>
Aut& vcsn::complete_here ( Aut &  aut)

Complete aut and return it.

Definition at line 13 of file complete.hh.

References has(), and vcsn::detail::out().

Referenced by complete().

Here is the call graph for this function:

template<Automaton Aut>
filter_automaton<scc_automaton<Aut> > vcsn::component ( const scc_automaton< Aut > &  aut,
unsigned  num 
)

An SCC as a subautomaton.

Parameters
autthe input automaton.
numthe number of the scc.

Definition at line 753 of file scc.hh.

template<Automaton Aut>
void vcsn::component ( const Aut &  ,
unsigned   
)

Definition at line 760 of file scc.hh.

template<typename ValueSet >
ValueSet::value_t vcsn::compose ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)
template<Automaton Lhs, Automaton Rhs, std::size_t OutTape = 1, std::size_t InTape = 0>
auto vcsn::compose ( const Lhs &  lhs,
const Rhs &  rhs 
)

Build the (accessible part of the) composition.

Definition at line 470 of file compose.hh.

References res.

template<typename Lhs , typename Rhs , std::size_t OutTape = 1, std::size_t InTape = 0>
auto vcsn::compose_lazy ( const Lhs &  lhs,
const Rhs &  rhs 
)

Build the (accessible part of the) lazy composition.

Definition at line 481 of file compose.hh.

References res.

Referenced by vcsn::dyn::compose().

template<Automaton Aut>
partition_automaton<scc_automaton<Aut> > vcsn::condense ( const scc_automaton< Aut > &  aut)

Create a condensation of automaton with each its state who is a strongly connected component of aut.

Definition at line 788 of file scc.hh.

template<Automaton Aut>
partition_automaton<Aut> vcsn::condense ( const Aut &  )

Definition at line 821 of file scc.hh.

template<Automaton Aut>
Aut vcsn::conjugate ( const Aut &  aut)

Definition at line 10 of file conjugate.hh.

References vcsn::detail::final_transitions(), vcsn::detail::initial_transitions(), make_copier(), require(), and res.

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::conjunction ( const Aut &  aut,
to  exp 
) -> fresh_automaton_t_of<Aut>

Repeated conjunction of a automaton.

Parameters
autthe automaton to conjoin with itself.
expthe "power": number of conjunction to apply.
Returns
A non-decorated automaton.

Definition at line 951 of file conjunction.hh.

References vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::conjunction(), make_fresh_automaton(), require(), res, and vcsn::detail::automaton_decorator< tuple_automaton< Aut, Auts... > >::strip().

Referenced by vcsn::dyn::detail::conjunction_expansion(), vcsn::dyn::detail::conjunction_expression(), vcsn::dyn::detail::conjunction_polynomial(), difference(), has_twins_property(), and info().

Here is the call graph for this function:

template<typename ValueSet >
ValueSet::value_t vcsn::conjunction ( const ValueSet &  rs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Intersection/Hadamard product of expressions/polynomials.

Definition at line 1027 of file conjunction.hh.

Referenced by vcsn::dyn::detail::conjunction_repeated().

template<typename ValueSet , typename... Args>
auto vcsn::conv ( const ValueSet &  vs,
const std::string &  str,
Args &&...  args 
) -> decltype(vs.conv(std::declval<std::istream&>(), std::forward<Args>(args)...))
template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename KeepState , typename KeepTrans >
auto vcsn::copy ( const AutIn &  input,
KeepState  keep_state,
KeepTrans  keep_trans 
) -> decltype(keep_state(input->null_state()), keep_trans(input->null_transition()), make_fresh_automaton<AutIn, AutOut>(input))

A copy of input keeping only its states that are accepted by keep_state, and transitions accepted by keep_trans.

Definition at line 322 of file copy.hh.

References copy_into(), and res.

Referenced by vcsn::detail::absval(), complement(), complete(), copy(), copy_into(), eliminate_state(), factor(), vcsn::detail::invalid_argument(), vcsn::detail::is_valid_impl< Aut, has_one >::is_valid_(), ldivide(), multiply_here(), vcsn::detail::epsilon_remover_distance< Aut, false >::operator()(), vcsn::detail::epsilon_remover< Aut, false >::operator()(), vcsn::detail::epsilon_remover_separate< Aut, false >::operator()(), prefix(), push_weights(), vcsn::ctx::detail::register_automaton_functions(), vcsn::detail::properer< Aut >::remover_(), standard(), and suffix().

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename KeepState >
auto vcsn::copy ( const AutIn &  input,
KeepState  keep_state 
) -> decltype(keep_state(input->null_state()), make_fresh_automaton<AutIn, AutOut>(input))

A copy of input.

Definition at line 338 of file copy.hh.

template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>>
AutOut vcsn::copy ( const AutIn &  input)

A copy of input.

Definition at line 354 of file copy.hh.

template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename States >
auto vcsn::copy ( const AutIn &  input,
const States &  ss 
) -> decltype(*ss.begin() == input->null_state(), make_fresh_automaton<AutIn, AutOut>(input))

A copy of input keeping only its states that are members of states.

Definition at line 370 of file copy.hh.

References has().

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename States , typename Trans >
auto vcsn::copy ( const AutIn &  input,
const States &  ss,
const Trans &  ts 
) -> decltype(*ss.begin() == input->null_state(), *ts.begin() == input->null_transition(), make_fresh_automaton<AutIn, AutOut>(input))

A copy of input keeping only its states that are members of container ss, and transitions that are members of container ts.

Definition at line 387 of file copy.hh.

References has().

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>, typename Transitions >
auto vcsn::copy ( const AutIn &  input,
const Transitions &  ts 
) -> decltype(*ts.begin() == input->null_transition(), make_fresh_automaton<AutIn, AutOut>(input))

A copy of input keeping only its transitions that are members of ts, and the states on which these transitions depend.

Definition at line 405 of file copy.hh.

References copy(), make_copier(), and res.

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut, typename KeepState , typename KeepTrans >
void vcsn::copy_into ( const AutIn &  in,
AutOut &  out,
KeepState  keep_state,
KeepTrans  keep_trans 
)

Copy selected states and transitions of an automaton.

Precondition
AutIn <: AutOut.

Definition at line 267 of file copy.hh.

References copy(), and make_copier().

Referenced by add_here(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::complement(), copy_into(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::ldivide(), vcsn::dyn::lweight(), vcsn::detail::epsilon_remover< Aut, has_one >::operator()(), project(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::rdivide(), vcsn::dyn::rweight(), and subword().

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut, typename KeepState >
void vcsn::copy_into ( const AutIn &  in,
AutOut &  out,
KeepState  keep_state 
)

Copy the selected states an automaton.

Precondition
AutIn <: AutOut.

Definition at line 278 of file copy.hh.

References copy_into().

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut>
void vcsn::copy_into ( const AutIn &  in,
AutOut &  out 
)

Copy an automaton.

Precondition
AutIn <: AutOut.

Definition at line 289 of file copy.hh.

References copy_into().

Here is the call graph for this function:

template<Automaton AutIn, Automaton AutOut>
void vcsn::copy_into ( const AutIn &  in,
AutOut &  out,
bool  safe 
)

Copy an automaton.

Parameters
ininput automaton, to copy
outoutput automaton, the destination
safewhether the input automaton is in normal form, i.e., never has two transitions with same (src, label, dst).
Precondition
AutIn <: AutOut.

Definition at line 308 of file copy.hh.

References copy(), and make_copier().

Referenced by copy(), and vcsn::dyn::detail::copy_convert().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::costandard ( const Aut &  aut) -> decltype(copy(aut))

Definition at line 125 of file standard.hh.

References standard(), and transpose().

Referenced by normalize().

Here is the call graph for this function:

template<typename PolynomialSet >
mutable_automaton<detail::free_context<context_t_of<PolynomialSet> > > vcsn::cotrie ( const PolynomialSet &  ps,
const typename PolynomialSet::value_t &  p 
)

Make a cotrie-like mutable_automaton for a finite series given as a polynomial.

Parameters
psthe polynomialset
pthe polynomial that specifies the series.

Definition at line 228 of file trie.hh.

Referenced by vcsn::dyn::cotrie(), and vcsn::dyn::detail::cotrie_stream().

template<typename PolynomialSet >
mutable_automaton<detail::free_context<context_t_of<PolynomialSet> > > vcsn::cotrie ( const PolynomialSet &  ps,
std::istream &  is,
const std::string &  format = "default" 
)

Make a trie-like mutable_automaton for a finite series read from a stream.

Parameters
psthe polynomialset
isthe stream to read
formatthe format of the file: "words" or "monomials"

Definition at line 287 of file trie.hh.

template<Automaton AutIn, Automaton AutOut>
void vcsn::create_states_and_trans_ ( const AutIn &  aut,
AutOut &  naut1,
AutOut &  naut2 
)

Create states and the transitions two new automata naut1 and naut2 with weight of transition <(w, one)> and <(one, w)> corresponding with the weight of transition <w> of aut.

Definition at line 102 of file has-twins-property.hh.

References vcsn::detail::all_transitions().

Referenced by has_twins_property().

Here is the call graph for this function:

template<typename... Sequences>
cross_sequences<Sequences...> vcsn::cross ( Sequences &&...  seqs)

Definition at line 287 of file cross.hh.

Referenced by vcsn::detail::tupleset_impl< ValueSets >::generators_().

template<typename... Sequences>
cross_sequences<Sequences...> vcsn::cross_tuple ( const std::tuple< Sequences... > &  seqs)

Definition at line 294 of file cross.hh.

template<Automaton Aut>
bool vcsn::cycle_identity ( const detail::component_t< Aut > &  c,
const Aut &  aut 
)

Check the weight of two states on this component is unique.

Definition at line 86 of file has-twins-property.hh.

References vcsn::detail::cycle_identity_impl< Aut >::check().

Referenced by has_twins_property().

Here is the call graph for this function:

template<Automaton Aut>
std::ostream& vcsn::daut ( const Aut &  aut,
std::ostream &  out = std::cout 
)

Print an automaton in Daut format.

Parameters
autthe automaton to print.
outthe output stream.

Definition at line 101 of file daut.hh.

References vcsn::detail::out().

Referenced by print().

Here is the call graph for this function:

template<typename Context >
mutable_automaton<Context> vcsn::de_bruijn ( const Context &  ctx,
unsigned  n 
)

Definition at line 17 of file de-bruijn.hh.

References vcsn::detail::ctx, vcsn::detail::front(), require(), and res.

Referenced by vcsn::ctx::detail::register_functions_is_free(), and vcsn::ctx::detail::register_kind_functions().

Here is the call graph for this function:

std::ostream & vcsn::decendl ( std::ostream &  o)

Decrement the indentation, print an end of line, and set the indentation.

Definition at line 59 of file indent.cc.

References decindent(), and iendl().

Referenced by vcsn::rat::dot_printer< ExpSet >::operator()(), and vcsn::rat::printer< ExpSet >::print_().

Here is the call graph for this function:

std::ostream & vcsn::decindent ( std::ostream &  o)

Decrement the indentation.

Definition at line 27 of file indent.cc.

References vcsn::detail::indentation.

Referenced by decendl().

template<typename ExpSet >
rat::expression_polynomial_t< ExpSet > vcsn::derivation ( const ExpSet &  rs,
const typename ExpSet::value_t &  e,
label_t_of< ExpSet >  a,
bool  breaking = false 
)

Derive an expression wrt to a letter.

Definition at line 287 of file derivation.hh.

References vcsn::detail::is_letterized(), res, and split().

Referenced by vcsn::detail::derived_term_automaton_impl< ExpSet >::complete_via_derivation_(), vcsn::dyn::derivation(), derivation(), vcsn::ctx::detail::register_functions_is_free(), and vcsn::rat::derivation_visitor< ExpSet >::visit_tuple< bool, Dummy >::work_().

Here is the call graph for this function:

template<typename ExpSet >
rat::expression_polynomial_t<ExpSet> vcsn::derivation ( const ExpSet &  rs,
const rat::expression_polynomial_t< ExpSet > &  p,
label_t_of< ExpSet >  a,
bool  breaking = false 
)

Derive a polynomial of expressions wrt to a letter.

Definition at line 305 of file derivation.hh.

References derivation(), label_of(), vcsn::rat::make_expression_polynomialset(), res, and weight_of().

Here is the call graph for this function:

template<typename ExpSet , typename = std::enable_if_t<!std::is_same<word_t_of<ExpSet>, label_t_of<ExpSet>>{}>>
rat::expression_polynomial_t<ExpSet> vcsn::derivation ( const ExpSet &  rs,
const typename ExpSet::value_t &  e,
const word_t_of< ExpSet > &  l,
bool  breaking = false 
)

Derive an expression wrt to a word.

Do not enable this overload when labels and words are the same thing (e.g., when working on a wordset), since in this case we fail with an ambiguous overload. Thanks to this enable_if, only the first overload (derivation wrt a label) is enabled, and the compilation fails but this time with the right diagnostic: the labelset must be free.

Definition at line 333 of file derivation.hh.

References derivation(), require(), and res.

Here is the call graph for this function:

template<typename ExpSet >
std::enable_if_t<labelset_t_of<ExpSet>::is_letterized(), expression_automaton<mutable_automaton<typename ExpSet::context_t> > > vcsn::derived_term ( const ExpSet &  rs,
const typename ExpSet::value_t &  r,
const std::string &  algo = "auto" 
)

The derived-term automaton, for letterized labelsets.

Parameters
rsthe expressionset
rthe expression
algothe algo to run: "auto", "derivation", or "expansion".

Definition at line 335 of file derived-term.hh.

References make_derived_term_automaton().

Referenced by are_equivalent(), and vcsn::ctx::detail::register_expression_functions().

Here is the call graph for this function:

template<typename ExpSet >
std::enable_if_t<!labelset_t_of<ExpSet>::is_letterized(), expression_automaton<mutable_automaton<typename ExpSet::context_t> > > vcsn::derived_term ( const ExpSet &  rs,
const typename ExpSet::value_t &  r,
const std::string &  algo = "auto" 
)

The derived-term automaton, for non letterized labelsets.

Parameters
rsthe expressionset
rthe expression
algothe algo to run: "auto", "derivation", or "expansion".

Definition at line 352 of file derived-term.hh.

References vcsn::detail::derived_term_algo::expansion, make_derived_term_automaton(), and require().

Here is the call graph for this function:

return vcsn::detail::static_if< detail::has_power_mem_fn< ValueSet >{}> ( [] (const auto &vs, const auto &v, auto n){return vs.power(v, n);}  ,
[] (const auto &vs, const auto &v, auto n){auto res=vs.one();if(!vs.is_one(v)) while(n--) res=vs.mul(res, v);return res;}   
)
template<Automaton Aut, bool Lazy = false>
auto vcsn::determinize ( const Aut &  a,
auto_tag  = {},
bool_constant< Lazy >  lazy = {} 
)

Determinization: automatic dispatch based on the automaton type.

Definition at line 273 of file determinize.hh.

template<Automaton Lhs, Automaton Rhs>
fresh_automaton_t_of<Lhs> vcsn::difference ( const Lhs &  lhs,
const Rhs &  rhs 
)

An automaton that computes weights of lhs, but not by rhs.

Definition at line 122 of file are-equivalent.hh.

References complement(), complete(), conjunction(), determinize(), is_complete(), is_deterministic(), and strip().

Referenced by are_equivalent().

Here is the call graph for this function:

template<typename ExpSet >
ExpSet::value_t vcsn::difference ( const ExpSet &  rs,
const typename ExpSet::value_t &  lhs,
const typename ExpSet::value_t &  rhs 
)

Difference of expressions.

Definition at line 156 of file are-equivalent.hh.

Referenced by vcsn::dyn::difference(), and vcsn::dyn::detail::difference_expression().

template<typename Context >
mutable_automaton<Context> vcsn::divkbaseb ( const Context &  ctx,
unsigned  divisor,
unsigned  base 
)

Build the Boolean automaton which accepts a word n representing a number in base "base" if and only if divisor|n.

Definition at line 16 of file divkbaseb.hh.

References vcsn::detail::ctx, require(), res, and VCSN_REQUIRE.

Referenced by vcsn::ctx::detail::register_functions_is_free(), and vcsn::ctx::detail::register_kind_functions().

Here is the call graph for this function:

template<Automaton Aut>
std::ostream& vcsn::dot ( const Aut &  aut,
std::ostream &  out = std::cout,
format  fmt = {},
bool  mathjax = false 
)

Print an automaton in Graphviz's Dot format.

Parameters
autthe automaton to print.
outthe output stream.
fmthow to format the automaton.
mathjaxshall it be formatted for MathJax.

Definition at line 395 of file dot.hh.

Referenced by vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover_(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::operator()(), and print().

template<typename Context >
mutable_automaton<Context> vcsn::double_ring ( const Context &  ctx,
unsigned  n,
const std::vector< unsigned > &  finals 
)

Definition at line 16 of file double-ring.hh.

References vcsn::detail::ctx, vcsn::detail::make_vector(), require(), and res.

Referenced by vcsn::ctx::detail::register_functions_is_free(), and vcsn::ctx::detail::register_kind_functions().

Here is the call graph for this function:

char vcsn::eat ( std::istream &  is,
char  c 
)
const std::string & vcsn::eat ( std::istream &  is,
const std::string &  s 
)

Check lookahead string and advance.

Parameters
isthe stream to read.
sthe expected string.
Returns
s
Exceptions
std::runtime_errorif the next character is not s.

Definition at line 101 of file stream.cc.

References str_escape(), and VCSN_REQUIRE.

Here is the call graph for this function:

template<Automaton Aut>
std::ostream& vcsn::efsm ( const Aut &  aut,
std::ostream &  out = std::cout 
)

Print automaton to EFSM format, based on FSM format.

Template Parameters
Autan automaton type.

Definition at line 332 of file efsm.hh.

References vcsn::detail::out().

Referenced by print().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::eliminate_state ( const Aut &  aut,
state_t_of< Aut >  s = Aut::element_type::null_state() 
) -> fresh_automaton_t_of<Aut>

A copy of automaton res without the state s.

Definition at line 449 of file to-expression.hh.

References copy(), eliminate_state_here(), make_copier(), and require().

Referenced by vcsn::dyn::eliminate_state(), eliminate_state_here(), and vcsn::ctx::detail::register_kind_functions().

Here is the call graph for this function:

template<Automaton Aut>
Aut& vcsn::eliminate_state_here ( Aut &  res,
state_t_of< Aut >  s = Aut::element_type::null_state() 
)

In place removal of state s from automaton res.

Definition at line 436 of file to-expression.hh.

References eliminate_state(), vcsn::detail::make_state_eliminator(), and res.

Referenced by eliminate_state().

Here is the call graph for this function:

template<Automaton Aut>
detail::enumerater<Aut>::polynomial_t vcsn::enumerate ( const Aut &  aut,
unsigned  len 
)

The approximated behavior of an automaton.

Parameters
autthe automaton whose behavior to approximate
lenmaximum length of words looked for.

Definition at line 305 of file shortest.hh.

References shortest().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::evaluate ( const Aut &  a,
const word_t_of< Aut > &  w 
) -> std::enable_if_t<!context_t_of<Aut>::is_lao, weight_t_of<Aut>>

General case of evaluation.

Definition at line 172 of file evaluate.hh.

Referenced by vcsn::ctx::detail::register_functions_is_free(), and weight_series().

template<Automaton Aut>
auto vcsn::evaluate ( const Aut &  a) -> std::enable_if_t<context_t_of<Aut>::is_lao, weight_t_of<Aut>>

Evaluation for lao automaton.

Require a proper automaton. In a proper lao automaton, an accepting path can only be composed by initial and final transitions. Sum the weight of these paths.

Definition at line 186 of file evaluate.hh.

References vcsn::detail::all_out(), vcsn::detail::initial_transitions(), is_proper(), vcsn::detail::out(), require(), and res.

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::evaluate ( const Aut &  a,
const typename detail::word_polynomialset_t< context_t_of< Aut >>::value_t &  p 
) -> weight_t_of<Aut>

Evaluation of a polynomial.

Definition at line 225 of file evaluate.hh.

Referenced by vcsn::dyn::detail::eval_polynomial(), and vcsn::dyn::evaluate().

bool vcsn::exists ( const path p)

Definition at line 98 of file path.cc.

References vcsn::path::c_str().

Referenced by vcsn::file_library::find_file(), and vcsn::file_library::find_in_search_path().

Here is the call graph for this function:

template<typename ExpSet >
ExpSet::value_t vcsn::expand ( const ExpSet &  rs,
const typename ExpSet::value_t &  r 
)

Expand a typed expression, i.e., distribute multiplications over sums.

Definition at line 13 of file expand.hh.

References conv(), make_expressionset(), and to_string().

Referenced by vcsn::ctx::detail::register_expression_functions().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::factor ( const Aut &  aut) -> decltype(::vcsn::copy(aut))

Definition at line 106 of file prefix.hh.

References copy(), factor_here(), and res.

Referenced by vcsn::detail::polynomialset_impl< Context, Kind >::add_ldivide_here().

Here is the call graph for this function:

template<Automaton Aut>
Aut& vcsn::factor_here ( Aut &  aut)

Make each useful state both initial and final.

Definition at line 99 of file prefix.hh.

References prefix_here(), and suffix_here().

Referenced by factor().

Here is the call graph for this function:

template<Automaton Aut>
std::ostream& vcsn::fado ( const Aut &  aut,
std::ostream &  out = std::cout 
)

Format automaton to FAdo format.

Template Parameters
Autan automaton type.

Definition at line 115 of file grail.hh.

References vcsn::detail::out().

Here is the call graph for this function:

template<typename... Args>
ATTRIBUTE_NORETURN void vcsn::fail_reading ( std::istream &  is,
Args &&...  args 
)

Throw an exception after failing to read from is.

Reset the stream to a "good" state, and read the presumably ill-formed input into a buffer string; then throw with the given explanation followed by the buffer string. explanation should not contain trailing punctuation or spaces.

Definition at line 68 of file stream.hh.

References str_escape().

Referenced by vcsn::ast::context_parser::check_eof_(), vcsn::detail::nmin_impl::conv(), vcsn::detail::min_plus_impl< zmin_impl, int >::conv(), vcsn::detail::z_impl::conv(), eat(), and operator>>().

Here is the call graph for this function:

template<typename Range , typename Filter >
auto vcsn::filter ( Range &&  r,
Filter  f,
decltype(f(*std::begin(r)), void())*  = nullptr 
)

Similar to boost::adaptors::filter, but ensures that the range is kept alive.

Definition at line 48 of file filter.hh.

template<Automaton Aut, bool Trans = false>
filter_automaton<Aut, Trans> vcsn::filter ( const Aut &  aut,
boost::optional< dynamic_bitset ss = {},
boost::optional< dynamic_bitset ts = {} 
)

Get an automaton who is a part state set ss of aut.

Definition at line 301 of file filter.hh.

Referenced by accessible(), coaccessible(), vcsn::detail::tupleset_impl< ValueSets >::generators_(), and trim().

template<Automaton Aut>
filter_automaton<Aut> vcsn::filter ( const Aut &  aut,
const std::unordered_set< state_t_of< Aut >> &  ss 
)

Definition at line 310 of file filter.hh.

template<unsigned Tape, Automaton Aut>
focus_automaton< Tape, Aut > vcsn::focus ( Aut  aut)

Definition at line 327 of file focus.hh.

template<Automaton Aut>
predecessors_t_of<Aut> vcsn::format_lightest ( const Aut &  aut,
const std::vector< transition_t_of< Aut >> &  path 
)

A state-indexed vector of predecessor transitions from the path path.

For each state s, res[s] is null_transition if it is not part of path (or it is its beginning), or res[s] is the transition index that points to the incoming transition to s in path.

Definition at line 241 of file k-lightest-path.hh.

References res, and vcsn::detail::states_size().

Referenced by lightest(), lightest_path(), and vcsn::detail::yen_impl< Aut, ValueSet, Mul, GetValue >::operator()().

Here is the call graph for this function:

char vcsn::get_char ( std::istream &  i)

Read a single char, with possible -escape support.

EOF is an error.

Definition at line 37 of file stream.cc.

References CASE, require(), and res.

Referenced by vcsn::char_letters::get_letter(), and vcsn::string_letters::get_letter().

Here is the call graph for this function:

std::string vcsn::get_file_contents ( const std::string &  file)

Return the contents of file.

Definition at line 119 of file stream.cc.

References vcsn::detail::in(), res, and VCSN_REQUIRE.

Here is the call graph for this function:

template<Automaton Aut>
std::ostream& vcsn::grail ( const Aut &  aut,
std::ostream &  out 
)

Print automaton in Grail format.

Template Parameters
Autan automaton type.

Definition at line 185 of file grail.hh.

References vcsn::detail::out().

Here is the call graph for this function:

template<typename Map , typename Key >
auto vcsn::has ( const Map &  s,
const Key &  e 
) -> decltype(s.find(e) != std::end(s))

Whether e is in s.

Definition at line 13 of file bimap.hh.

template<typename T , typename U >
bool vcsn::has ( std::initializer_list< T >  s,
const U &  e 
)
inline

Whether e is in s.

Definition at line 13 of file initializer_list.hh.

template<typename T , typename Allocator = std::allocator<T>>
ATTRIBUTE_PURE bool vcsn::has ( const std::deque< T, Allocator > &  s,
const T &  e 
)

Whether e is member of s.

Definition at line 15 of file deque.hh.

template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >
bool vcsn::has ( const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &  m,
const Key &  k 
)

Whether e is member of m.

Definition at line 24 of file unordered_map.hh.

template<typename Key , typename Compare , typename Allocator >
ATTRIBUTE_PURE bool vcsn::has ( const boost::container::flat_set< Key, Compare, Allocator > &  s,
const Key &  e 
)

Whether e is member of s.

Definition at line 25 of file setalpha.hh.

Referenced by vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::add_add_transitions(), vcsn::ast::context_parser::any_(), aut_of_component(), vcsn::detail::cycle_identity_impl< Aut >::check(), vcsn::rat::expansionset< expressionset_t >::complement_(), complement_here(), vcsn::detail::determinized_automaton_impl< Aut, Kind, Lazy >::complete_(), complete_here(), vcsn::detail::scc_impl< Aut, dijkstra_tag >::components(), copy(), vcsn::detail::reverse_postorder_impl< Aut >::dfs(), vcsn::detail::scc_impl< Aut, dijkstra_tag >::dfs(), vcsn::detail::scc_impl< Aut, kosaraju_tag >::dfs(), vcsn::detail::scc_impl< Aut, tarjan_iterative_tag >::dfs(), vcsn::detail::scc_impl< Aut, tarjan_recursive_tag >::dfs(), vcsn::set_alphabet< L >::has(), vcsn::are_isomorphicer< Aut1, Aut2 >::is_isomorphism_valid_throwing(), is_partial_identity(), vcsn::ast::context_parser::labelset_or_weightset_(), vcsn::rat::expansionset< expressionset_t >::ldivide(), vcsn::rat::expressionset_impl< Context >::letter_class_(), num_accessible_states(), num_useful_states(), vcsn::detail::is_ambiguous_impl< Aut >::operator()(), vcsn::detail::a_star_impl< Aut >::operator()(), vcsn::detail::random_expression_impl< ExpressionSet, RandomGenerator >::parse_param_(), vcsn::detail::dot_impl< Aut >::print_state_(), vcsn::detail::dot_impl< Aut >::print_transitions_(), set_intersection(), ss_shortest_distance(), vcsn::detail::polystate_automaton_impl< Aut, Kind, Lazy >::state_has_name(), vcsn::detail::tuple_automaton_impl< Aut, Auts >::state_has_name(), vcsn::detail::pair_automaton_impl< Aut >::state_has_name(), vcsn::rat::standard_visitor< Aut, ExpSet >::VCSN_RAT_VISIT(), vcsn::ast::context_parser::weightset_(), and vcsn::detail::universal_impl< Aut >::work_().

template<typename T , typename Container >
ATTRIBUTE_PURE bool vcsn::has ( const std::queue< T, Container > &  s,
const T &  e 
)

Whether e is member of s.

Definition at line 29 of file queue.hh.

template<typename T , typename Alloc >
ATTRIBUTE_PURE bool vcsn::has ( const std::vector< T, Alloc > &  s,
const T &  e 
)

Whether e is member of s.

Definition at line 32 of file vector.hh.

template<typename T , typename Compare , typename Alloc >
bool vcsn::has ( const std::set< T, Compare, Alloc > &  s,
const T &  e 
)

Whether e is member of s.

Definition at line 9 of file set.hxx.

template<typename Key , typename Hash , typename KeyEqual , typename Alloc >
bool vcsn::has ( const std::unordered_set< Key, Hash, KeyEqual, Alloc > &  s,
const Key &  k 
)

Whether e is member of s.

Definition at line 37 of file unordered_set.hh.

template<typename Key , typename Value , typename Compare , typename Alloc >
bool vcsn::has ( const std::map< Key, Value, Compare, Alloc > &  s,
const Key &  e 
)
inline

Whether e is in s.

Definition at line 38 of file map.hh.

template<typename Key , typename Value >
bool vcsn::has ( const sparse_map< Key, Value > &  s,
Key  k 
)

Definition at line 128 of file sparse-map.hh.

References vcsn::sparse_map< Key, Value >::has().

Here is the call graph for this function:

template<typename T >
bool vcsn::has ( const sparse_set< T > &  s,
e 
)

Definition at line 129 of file sparse-set.hh.

References vcsn::sparse_set< T >::has().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::has_bounded_lag ( const Aut &  aut)

Whether a transducer has a bounded lag.

Parameters
[in]autthe transducer
Returns
whether the lag is bounded

Definition at line 150 of file has-bounded-lag.hh.

References vcsn::detail::bounded_lag_checker< Aut >::has_bounded_lag().

Here is the call graph for this function:

template<Automaton Aut>
std::enable_if_t<weightset_t_of<Aut>::has_lightening_weights(), bool> vcsn::has_lightening_cycle ( const Aut &  aut)

Definition at line 17 of file has-lightening-cycle.hh.

References vcsn::detail::bellman_ford_impl().

Referenced by vcsn::detail::lightest_impl< Aut >::operator()().

Here is the call graph for this function:

template<Automaton Aut>
std::enable_if_t<!weightset_t_of<Aut>::has_lightening_weights(), bool> vcsn::has_lightening_cycle ( const Aut &  aut)

Definition at line 24 of file has-lightening-cycle.hh.

template<Automaton Aut>
bool vcsn::has_twins_property ( const Aut &  aut)

Whether aut has the twins property.

Definition at line 132 of file has-twins-property.hh.

References conjunction(), create_states_and_trans_(), cycle_identity(), is_cycle_ambiguous(), make_context(), make_mutable_automaton(), require(), strong_components(), tarjan_iterative, and trim().

Here is the call graph for this function:

std::ostream & vcsn::iendl ( std::ostream &  o)

Print an end of line, then set the indentation.

Definition at line 49 of file indent.cc.

References indent().

Referenced by decendl(), incendl(), vcsn::rat::dot_printer< ExpSet >::operator()(), vcsn::rat::dot_printer< ExpSet >::visit_tuple< typename >::operator()(), vcsn::rat::dot_printer< ExpSet >::visit_tuple< typename >::print_(), vcsn::rat::dot_printer< ExpSet >::print_(), and vcsn::ast::context_printer::visit().

Here is the call graph for this function:

vcsn::if ( exp.  max = = -1)
vcsn::if ( )

Definition at line 390 of file multiply.hh.

References vcsn::to::max, and vcsn::to::min.

template<typename Key , typename Value , typename Comp , typename Alloc >
std::set<typename std::map<Key, Value, Comp, Alloc>::mapped_type> vcsn::image ( const std::map< Key, Value, Comp, Alloc > &  m)

The set of values of a map.

Definition at line 46 of file map.hh.

References res.

Referenced by vcsn::detail::universal_impl< Aut >::work_().

template<Automaton Aut>
bool vcsn::in_situ_remover ( Aut &  aut,
bool  prune = true 
)
std::ostream & vcsn::incendl ( std::ostream &  o)

Increment the indentation, print an end of line, and set the indentation.

Definition at line 54 of file indent.cc.

References iendl(), and incindent().

Referenced by vcsn::rat::dot_printer< ExpSet >::operator()(), vcsn::rat::printer< ExpSet >::print_(), and vcsn::ast::context_printer::visit().

Here is the call graph for this function:

std::ostream & vcsn::incindent ( std::ostream &  o)

Increment the indentation.

Definition at line 21 of file indent.cc.

References vcsn::detail::indentation.

Referenced by incendl().

std::ostream & vcsn::indent ( std::ostream &  o)

Set the indentation.

Definition at line 40 of file indent.cc.

References vcsn::detail::indentation.

Referenced by iendl().

template<Automaton Aut, typename ExpSet , typename Tag >
Aut vcsn::inductive ( const ExpSet &  rs,
const typename ExpSet::value_t &  r,
Tag  = {} 
)

Build a inductive automaton from an expression.

Template Parameters
Autthe type of the generated automaton.
ExpSetthe expressionset.
Tagthe nature of the operations (standard_tag, etc.).

Definition at line 304 of file inductive.hh.

Referenced by vcsn::ctx::detail::register_expression_functions().

template<Automaton A1, Automaton A2>
auto vcsn::infiltrate ( const A1 &  a1,
const A2 &  a2 
) -> tuple_automaton<decltype(join_automata(a1, a2)), A1, A2>

The (accessible part of the) infiltration product.

Definition at line 861 of file conjunction.hh.

References vcsn::detail::join_automata(), and res.

Referenced by vcsn::dyn::detail::infiltrate_(), vcsn::dyn::detail::infiltrate_expression(), and info().

Here is the call graph for this function:

template<Automaton A1, Automaton A2, Automaton A3, Automaton... Auts>
auto vcsn::infiltrate ( const A1 &  a1,
const A2 &  a2,
const A3 &  a3,
const Auts &...  as 
) -> decltype(infiltrate(infiltrate(a1, a2), a3, as...))

The (accessible part of the) infiltration product.

Definition at line 874 of file conjunction.hh.

References vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::infiltrate().

Here is the call graph for this function:

template<typename ValueSet >
ValueSet::value_t vcsn::infiltrate ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Infiltration product of expressions.

Definition at line 913 of file conjunction.hh.

template<Automaton Aut>
std::ostream& vcsn::info ( const Aut &  aut,
std::ostream &  out = std::cout,
unsigned  details = 2 
)
template<typename ExpSet >
void vcsn::info ( const ExpSet &  rs,
const typename ExpSet::value_t &  e,
std::ostream &  o = std::cout 
)

Print info about the expression.

Definition at line 153 of file info.hh.

References add(), complement(), compose(), conjunction(), ECHO, infiltrate(), info(), ldivide(), lweight(), rweight(), shuffle(), vcsn::format::sname, star(), and tuple().

Here is the call graph for this function:

template<typename T , typename Compare , typename Alloc >
std::set< std::set< T, Compare, Alloc > > vcsn::intersection_closure ( std::set< std::set< T, Compare, Alloc >>  pset)

The set of all the intersections of the sets in pset.

Definition at line 17 of file set.hxx.

References set_intersection().

Referenced by vcsn::detail::universal_impl< Aut >::work_().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_accessible ( const Aut &  a)

Whether all its states are accessible.

Definition at line 175 of file accessible.hh.

References num_accessible_states().

Referenced by vcsn::are_isomorphicer< Aut1, Aut2 >::get_full_response().

Here is the call graph for this function:

template<Automaton Aut>
ATTRIBUTE_CONST bool vcsn::is_acyclic ( const Aut &  aut)

Definition at line 133 of file is-acyclic.hh.

Referenced by is_eps_acyclic().

template<Automaton Aut>
bool vcsn::is_ambiguous ( const Aut &  aut)

Whether an automaton is ambiguous.

Parameters
[in]autthe automaton.
Returns
whether ambiguous.

Definition at line 85 of file is-ambiguous.hh.

Referenced by ambiguous_word(), info(), and vcsn::ctx::detail::register_functions_is_free().

template<Automaton Aut>
bool vcsn::is_coaccessible ( const Aut &  a)

Whether all its states are coaccessible.

Definition at line 182 of file accessible.hh.

References num_coaccessible_states().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_codeterministic ( const Aut &  aut)

Whether the transposed automaton is deterministic.

Definition at line 73 of file is-deterministic.hh.

References is_deterministic(), and transpose().

Referenced by info().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_complete ( const Aut &  aut)

Whether aut is complete.

Precondition
aut is LTL

Definition at line 14 of file is-complete.hh.

References vcsn::detail::all_out().

Referenced by complement_here(), difference(), info(), vcsn::detail::universal_impl< Aut >::operator()(), and vcsn::ctx::detail::register_functions_is_free().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_costandard ( const Aut &  a)

Whether a is costandard.

Definition at line 41 of file standard.hh.

References is_standard(), and transpose().

Referenced by is_normalized().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_cycle_ambiguous ( const Aut &  aut)

Whether aut is cycle-ambiguous.

Definition at line 141 of file is-ambiguous.hh.

References aut_of_component(), is_cycle_ambiguous_scc(), strong_components(), and tarjan_iterative.

Referenced by has_twins_property(), and info().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_cycle_ambiguous_scc ( const Aut &  aut)

Whether aut is cycle-ambiguous.

Precondition
aut is a strongly connected component.

Definition at line 162 of file is-ambiguous.hh.

References vcsn::dyn::conjunction(), strong_components(), and tarjan_iterative.

Referenced by is_cycle_ambiguous().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_deterministic ( const Aut &  aut,
state_t_of< Aut >  s 
)

Whether state s is deterministic in aut.

Definition at line 16 of file is-deterministic.hh.

References vcsn::detail::all_out().

Referenced by complement_here(), difference(), vcsn::detail::dispatch_tags(), info(), is_codeterministic(), is_deterministic(), vcsn::detail::fado_impl< Aut >::is_deterministic_(), vcsn::detail::minimizer< Aut, moore_tag >::minimizer(), num_deterministic_states(), vcsn::detail::universal_impl< Aut >::operator()(), and vcsn::ctx::detail::register_functions_is_free().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_deterministic ( const Aut &  aut)

Whether has at most an initial state, and all its states are deterministic.

Definition at line 56 of file is-deterministic.hh.

References vcsn::detail::initial_transitions(), is_deterministic(), and vcsn::rat::size().

Here is the call graph for this function:

template<Automaton Aut>
ATTRIBUTE_CONST std::enable_if_t<context_t_of<Aut>::has_one(), bool> vcsn::is_eps_acyclic ( const Aut &  aut)

Detect epsilon-circuits.

In this algorithm, only epsilon-transitions are considered.

Definition at line 116 of file is-acyclic.hh.

References is_acyclic().

Referenced by info(), vcsn::detail::is_valid_impl< Aut, has_one >::is_valid_(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
ATTRIBUTE_CONST std::enable_if_t<!context_t_of<Aut>::has_one(), bool> vcsn::is_eps_acyclic ( const Aut &  )

Definition at line 125 of file is-acyclic.hh.

template<Automaton Aut>
constexpr bool vcsn::is_free_boolean ( )

Definition at line 10 of file is-free-boolean.hh.

template<Automaton Aut>
bool vcsn::is_functional ( const Aut &  aut)

Whether aut is functional.

Precondition
aut is a transducer.

Definition at line 17 of file is-functional.hh.

References is_partial_identity().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_letterized ( const Aut &  aut)

Check if the transitions are all letters.

Parameters
[in]autthe automaton
Returns
whether the transitions are letters

Definition at line 190 of file letterize.hh.

References vcsn::detail::is_letterized().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_normalized ( const Aut &  a)

Whether a is standard and co-standard.

Definition at line 12 of file normalize.hh.

References is_costandard(), and is_standard().

Referenced by info(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_out_sorted ( const Aut &  a)

Whether for each state, the outgoing transitions are sorted by increasing label.

Definition at line 59 of file sort.hh.

References vcsn::detail::is_sorted_forward(), and vcsn::detail::out().

Referenced by vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_partial_identity ( const Aut &  aut)

Whether transducer aut is equivalent to a partial identity function on all successful paths.

This automaton is expected to be two-tape, both tapes having the same labelset.

Words of the k-tape automaton: k-tuples of words.

Common labelset for both tapes.

Residue of input and output paths arriving to a given state, with longest common prefix eliminated.

Definition at line 21 of file is-partial-identity.hh.

References vcsn::detail::all_out(), coaccessible_states(), has(), vcsn::detail::make_wordset(), vcsn::weightset_mixin< WeightSet >::mul(), and vcsn::detail::rs.

Referenced by is_functional().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_proper ( const Aut &  aut)

Test whether an automaton is proper.

An automaton is proper iff it contains no epsilon-transition.

Parameters
autThe tested automaton
Returns
true iff the automaton is proper

Definition at line 47 of file is-proper.hh.

References vcsn::detail::is_proper_().

Referenced by evaluate(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::infiltrate(), info(), is_realtime(), vcsn::detail::is_valid_impl< Aut, has_one >::is_valid_(), vcsn::ctx::detail::register_functions(), and vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::shuffle().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_realtime ( const Aut &  aut)

Check if the automaton is realtime, i.e.

it is letterized and proper.

Parameters
[in]autthe automaton
Returns
whether the automaton is realtime

Definition at line 248 of file letterize.hh.

References vcsn::dyn::detail::is_letterized(), and is_proper().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_standard ( const Aut &  a)

Whether a is standard.

Definition at line 28 of file standard.hh.

References vcsn::detail::in(), and vcsn::detail::initial_transitions().

Referenced by add_here(), vcsn::detail::dispatch_tags(), info(), is_costandard(), is_normalized(), vcsn::detail::standard_operations< Aut >::lweight_here(), vcsn::ctx::detail::register_functions(), standard_here(), and star_here().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_synchronized ( const Aut &  aut)

Check whether the transducer is synchronized.

Parameters
[in]autthe transducer
Returns
whether it is synchronized

Definition at line 309 of file is-synchronized.hh.

template<Automaton Aut>
bool vcsn::is_synchronized_by ( const Aut &  aut,
const word_t_of< Aut > &  w 
)

Whether w synchronizes automaton aut.

Definition at line 36 of file synchronizing-word.hh.

References vcsn::detail::out(), require(), and vcsn::rat::size().

Referenced by vcsn::dyn::is_synchronized_by(), and vcsn::ctx::detail::register_functions_is_free().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_synchronizing ( const Aut &  aut)

Whether this automaton is synchronizing, i.e., has synchronizing words.

Definition at line 390 of file synchronizing-word.hh.

References vcsn::detail::word_synchronizer< Aut >::is_synchronizing().

Referenced by info(), vcsn::dyn::is_synchronizing(), and vcsn::ctx::detail::register_functions_is_free().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_trim ( const Aut &  a)

Whether all its states are useful.

Definition at line 161 of file accessible.hh.

References num_useful_states().

Referenced by info(), vcsn::detail::minimizer< Aut, moore_tag >::minimizer(), vcsn::detail::minimizer< Aut, weighted_tag >::minimizer(), vcsn::detail::minimizer< Aut, signature_tag >::minimizer(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_useless ( const Aut &  a)

Whether all no state is useful.

Definition at line 168 of file accessible.hh.

References num_useful_states().

Referenced by are_equivalent(), info(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_valid ( const Aut &  aut)

Definition at line 139 of file is-valid.hh.

References vcsn::detail::is_valid_impl< Aut, has_one >::is_valid().

Referenced by info(), vcsn::dyn::detail::is_valid_expression(), vcsn::detail::properer< Aut >::proper_star_(), vcsn::detail::properer< Aut >::proper_star_here_(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<typename ExpSet >
bool vcsn::is_valid ( const ExpSet &  rs,
const typename ExpSet::value_t &  e 
)

Whether e has only computable stars.

Definition at line 18 of file is-valid-expression.hh.

References constant_term().

Here is the call graph for this function:

template<typename ValueSet1 , typename ValueSet2 >
auto vcsn::join ( ValueSet1  vs1,
ValueSet2  vs2 
) -> decltype(detail::join_(vs1, vs2, 0))

The join of two valuesets.

Definition at line 53 of file join.hh.

References vcsn::detail::join_().

Here is the call graph for this function:

template<typename ValueSet1 , typename ValueSet2 , typename ValueSet3 , typename... VSs>
auto vcsn::join ( ValueSet1  vs1,
ValueSet2  vs2,
ValueSet3  vs3,
VSs &&...  vs 
)

The join of three (or more) valuesets.

We once had a single case for two-and-more arguments (instead of one join for two and one join for three-and-more), but the decltype() used in the return type failed to find the appropriate 'recursive' call to join in the case of three rat::identities. It turns out that removing the return type (and leaving its computation to the C++14 compiler) suffices to force the instantiation of the function, and to fix the problem.

Definition at line 71 of file join.hh.

References join().

Referenced by vcsn::detail::join_().

Here is the call graph for this function:

template<typename WeightSet , typename ExpSet >
expansionset<expressionset<context<labelset_t_of<ExpSet>, join_t<WeightSet, weightset_t_of<ExpSet> > > > > vcsn::join_weightset_expansionset ( const WeightSet ws,
const expansionset< ExpSet > &  rs 
)

Definition at line 201 of file weight.hh.

References vcsn::rat::expansionset< ExpSet >::expressionset(), join_weightset_expressionset(), and make_expansionset().

Referenced by vcsn::dyn::detail::lweight_expansion(), and vcsn::dyn::detail::rweight_expansion().

Here is the call graph for this function:

template<typename WeightSet , typename ExpSet >
expressionset<context<labelset_t_of<ExpSet>, join_t<WeightSet, weightset_t_of<ExpSet> > > > vcsn::join_weightset_expressionset ( const WeightSet ws,
const ExpSet &  rs 
)

Join between an expressionset and a weightset.

We must not perform a plain

join(w1.weightset(), r1.expressionset())

here. Consider for instance

expressionset<lal(abc), expressionset<law(xyz), b>>

we would perform

join(expressionset<law(xyz), b>, expressionset<lal(abc), expressionset<law(xyz), b>>)

i.e., a join of contexts which applies to both labelsets (here, join(lal(abc), "law(xyz)) = law(abcxyz)") and weightsets. Here, the "expressionset<law(xyz), b>" must really be considered as a weightset, so compute the join of weightsets by hand, and leave the labelset alone.

Definition at line 255 of file weight.hh.

References vcsn::detail::ctx, join(), make_context(), and make_expressionset().

Referenced by join_weightset_expansionset(), vcsn::dyn::detail::lweight_expression(), and vcsn::dyn::detail::rweight_expression().

Here is the call graph for this function:

template<typename WeightSet , typename ExpSet >
auto vcsn::join_weightset_polynomialset ( const WeightSet ws,
const polynomialset< ExpSet > &  ps 
)

Definition at line 287 of file weight.hh.

References join(), make_context(), and vcsn::detail::make_polynomialset().

Referenced by vcsn::dyn::detail::lweight_polynomial(), and vcsn::dyn::detail::rweight_polynomial().

Here is the call graph for this function:

template<Automaton Aut>
std::vector<path_t_of<Aut> > vcsn::k_lightest_path ( const Aut &  aut,
state_t_of< Aut >  src,
state_t_of< Aut >  dst,
unsigned  k 
)

Definition at line 221 of file k-lightest-path.hh.

References vcsn::detail::make_yen().

Referenced by lightest(), and lightest_path().

Here is the call graph for this function:

template<typename LabelSet >
auto vcsn::label_is_zero ( const LabelSet &  ls,
const typename LabelSet::value_t *  l 
) -> decltype(ls.is_zero(l), bool())
template<typename LabelSet >
bool vcsn::label_is_zero ( const LabelSet &  ,
  ... 
)

Definition at line 54 of file polynomialset.hh.

template<typename Label , typename Weight >
auto vcsn::label_of ( const welement< Label, Weight > &  m) -> decltype(m.label())

The label of a welement.

Definition at line 146 of file wet.hh.

Referenced by vcsn::detail::polynomialset_impl< Context, Kind >::abs(), vcsn::detail::trie_builder< Context, Dir >::add(), vcsn::edit_automaton< Aut >::add_entry(), vcsn::detail::polynomialset_impl< Context, Kind >::add_here(), vcsn::rat::split_visitor< ExpSet >::conjunction(), vcsn::detail::polynomialset_impl< Context, Kind >::conjunction_impl_(), vcsn::detail::polynomialset_impl< Context, Kind >::conv(), derivation(), vcsn::rat::expansionset< expressionset_t >::for(), vcsn::detail::polynomialset_impl< Context, Kind >::hash(), vcsn::detail::polynomialset_impl< Context, Kind >::infiltrate(), vcsn::detail::polynomialset_impl< Context, Kind >::ldivide(), vcsn::detail::polynomialset_impl< Context, Kind >::lmul_label(), vcsn::detail::polynomialset_impl< Context, Kind >::lweight(), minimize(), vcsn::detail::polynomialset_impl< Context, Kind >::monomial_equal(), vcsn::detail::polynomialset_impl< Context, Kind >::monomial_less(), vcsn::detail::polynomialset_impl< Context, Kind >::mul(), vcsn::detail::polynomialset_impl< Context, Kind >::mul_impl_(), vcsn::detail::evaluator< Aut >::operator()(), vcsn::detail::polynomialset_impl< Context, Kind >::print_with_classes_(), vcsn::rat::split_visitor< ExpSet >::product(), vcsn::detail::polynomialset_impl< Context, Kind >::project(), vcsn::detail::polynomialset_impl< Context, Kind >::rmul_label(), vcsn::rat::expansionset< expressionset_t >::rweight(), vcsn::detail::polynomialset_impl< Context, Kind >::rweight(), vcsn::rat::expansionset< expressionset_t >::shuffle_(), split_polynomial(), vcsn::detail::polynomialset_impl< Context, Kind >::sub_here(), vcsn::detail::polynomialset_impl< Context, Kind >::to_label(), vcsn::detail::polynomialset_impl< Context, Kind >::transpose(), vcsn::rat::derivation_visitor< ExpSet >::VCSN_RAT_VISIT(), vcsn::rat::to_expansion_visitor< expressionset_t >::VCSN_RAT_VISIT(), vcsn::detail::wet_bitset::wet_bitset(), vcsn::detail::wet_set< Key, Compare >::wet_set(), and vcsn::detail::universal_impl< Aut >::work_().

template<typename Label , typename Weight >
const Label& vcsn::label_of ( const std::pair< Label, Weight > &  m)

The label of a pair (label, weight).

Definition at line 169 of file wet.hh.

template<typename Label , typename Weight >
Label& vcsn::label_of ( std::pair< Label, Weight > &  m)

The label of a pair (label, weight).

Definition at line 183 of file wet.hh.

template<typename Context >
mutable_automaton<Context> vcsn::ladybird ( const Context &  ctx,
unsigned  n 
)

Build the ladybird automaton of n states.

Definition at line 14 of file ladybird.hh.

References make_mutable_automaton(), vcsn::detail::make_vector(), require(), and res.

Referenced by vcsn::ctx::detail::register_functions_is_free(), and vcsn::ctx::detail::register_kind_functions().

Here is the call graph for this function:

template<typename ValueSet >
ValueSet::value_t vcsn::ldivide ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Left-division of values.

Definition at line 15 of file divide.hh.

template<Automaton Aut1, Automaton Aut2>
auto vcsn::ldivide ( const Aut1 &  lhs,
const Aut2 &  rhs,
auto_tag  = {} 
)

Compute the left quotient.

Parameters
lhsleft hand side
rhsright hand side

Definition at line 684 of file conjunction.hh.

Referenced by info().

template<Automaton Aut1, Automaton Aut2>
auto vcsn::ldivide ( const Aut1 &  lhs,
const Aut2 &  rhs,
boolean_tag   
)

Definition at line 701 of file conjunction.hh.

References copy(), vcsn::detail::insplit(), vcsn::detail::join_automata(), and res.

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
auto vcsn::ldivide ( const Aut1 &  lhs,
const Aut2 &  rhs,
weighted_tag   
)

Definition at line 716 of file conjunction.hh.

References vcsn::detail::join_automata().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::left_reduce ( const Aut &  input) -> decltype(copy(input))

Definition at line 598 of file reduce.hh.

Referenced by reduce().

template<typename ExpSet >
bool vcsn::less_than ( const ExpSet &  rs,
const typename ExpSet::value_t &  lhs,
const typename ExpSet::value_t &  rhs 
)

Whether lhs precedes rhs.

Definition at line 17 of file less-than.hh.

Referenced by vcsn::dyn::detail::less_than_expression().

template<Automaton Aut>
auto vcsn::letterize ( const Aut &  aut) -> decltype(detail::letterize(aut))

Split the word transitions in the input automaton into letter ones.

Parameters
[in]autthe automaton
Returns
the letterized automaton

Definition at line 134 of file letterize.hh.

References vcsn::detail::letterize().

Referenced by realtime().

Here is the call graph for this function:

template<typename Context >
mutable_automaton<Context> vcsn::levenshtein ( const Context &  ctx)

The Levenshtein automaton for a given context.

Definition at line 14 of file levenshtein.hh.

References make_mutable_automaton(), vcsn::detail::make_vector(), res, and vcsn::rat::size().

Here is the call graph for this function:

template<typename ValueSet >
ValueSet::value_t vcsn::lgcd ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Left-division of values.

Definition at line 91 of file divide.hh.

Referenced by vcsn::detail::tupleset_impl< ValueSets >::lnormalize_here_().

template<Automaton Aut, size_t... Tapes>
detail::lifted_automaton_t<Aut, Tapes...> vcsn::lift ( const Aut &  a,
vcsn::rat::identities  ids = {} 
)

Lift some tapes of the transducer.

Parameters
athe input automaton
idsthe identities to use for the generated expressions

Definition at line 215 of file lift.hh.

Referenced by to_expression_heuristic().

template<typename ExpSet >
detail::lifted_expressionset_t<ExpSet>::value_t vcsn::lift ( const ExpSet &  rs,
const typename ExpSet::value_t &  e 
)

Move all the labels to the weights.

Definition at line 293 of file lift.hh.

References vcsn::detail::lift_expressionset().

Referenced by vcsn::dyn::detail::lift_automaton(), and vcsn::dyn::detail::lift_expression().

Here is the call graph for this function:

template<Automaton Aut>
detail::word_polynomialset_t<context_t_of<Aut> >::value_t vcsn::lightest ( const Aut &  aut,
unsigned  num = 1,
const std::string &  algo = "auto" 
)

The approximated behavior of an automaton.

Parameters
autthe automaton whose behavior to approximate
numnumber of words looked for
algothe algorithm to use.

Definition at line 191 of file lightest.hh.

References format_lightest(), k_lightest_path(), lightest_path(), vcsn::detail::make_word_polynomialset(), path_monomial(), and res.

Here is the call graph for this function:

template<Automaton Aut, typename Algo = auto_tag>
fresh_automaton_t_of<Aut> vcsn::lightest_automaton ( const Aut &  aut,
unsigned  k,
Algo  algo = {} 
)

Lightest Automaton.

An automaton composed only of the states included in the lightest path from pre to post. Using the shortest path algorithm given as parameter to compute the lightest 'in' transition of each state. Then, reconstruct the path keeping the states and transitions we met. Now that we have the sets of elements to keep we can construct a new automaton using these states/transitions.

Definition at line 22 of file lightest-automaton.hh.

template<Automaton Aut, typename Tag = auto_tag>
std::vector<transition_t_of<Aut> > vcsn::lightest_path ( const Aut &  aut,
Tag  tag = {} 
)

Lightest path dispatch between algorithms with tags.

Definition at line 19 of file lightest-path.hh.

template<Automaton Aut>
std::vector<transition_t_of<Aut> > vcsn::lightest_path ( const Aut &  aut,
state_t_of< Aut >  source,
state_t_of< Aut >  dest,
auto_tag  = {} 
)

Definition at line 26 of file lightest-path.hh.

template<Automaton Aut>
std::vector<transition_t_of<Aut> > vcsn::lightest_path ( const Aut &  aut,
state_t_of< Aut >  src,
state_t_of< Aut >  dst,
const std::string &  algo 
)

Lightest path dispatch between algorithms with string.

Definition at line 50 of file lightest-path.hh.

template<Automaton Aut>
std::vector<transition_t_of<Aut> > vcsn::lightest_path ( const Aut &  aut,
state_t_of< Aut >  source,
state_t_of< Aut >  ,
bellman_ford_tag   
)

Destination is ignored as bellman-ford does not stop when reaching dest, but when each iteration has been done.

Definition at line 77 of file bellman-ford.hh.

References vcsn::detail::bellman_ford_impl(), require(), and res.

Here is the call graph for this function:

template<Automaton Aut>
std::vector<transition_t_of<Aut> > vcsn::lightest_path ( const Aut &  aut,
state_t_of< Aut >  source,
state_t_of< Aut >  dest,
dijkstra_tag   
)

Definition at line 137 of file dijkstra.hh.

References vcsn::detail::make_dijkstra_impl().

Here is the call graph for this function:

template<Automaton Aut>
std::vector<transition_t_of<Aut> > vcsn::lightest_path ( const Aut &  aut,
state_t_of< Aut >  source,
state_t_of< Aut >  dest,
a_star_tag   
)

Definition at line 151 of file a-star.hh.

Referenced by lightest(), and vcsn::detail::lightest_path_tag().

template<Automaton Aut>
predecessors_t_of<Aut> vcsn::lightest_path ( const Aut &  aut,
state_t_of< Aut >  src,
state_t_of< Aut >  dst,
yen_tag   
)

Definition at line 252 of file k-lightest-path.hh.

References format_lightest(), k_lightest_path(), and res.

Here is the call graph for this function:

template<typename PolynomialSet >
std::ostream& vcsn::list ( const PolynomialSet &  ps,
const typename PolynomialSet::value_t &  p,
std::ostream &  o = std::cout 
)

Definition at line 249 of file print.hh.

Referenced by vcsn::dyn::detail::list_polynomial().

template<Automaton Aut, typename Tag = auto_tag>
auto vcsn::lweight ( const weight_t_of< Aut > &  w,
const Aut &  aut,
Tag  tag = {} 
) -> fresh_automaton_t_of<Aut>

Left-multiplication of an automaton by a weight.

Definition at line 126 of file weight.hh.

Referenced by info().

template<typename ValueSet >
auto vcsn::lweight ( const ValueSet &  rs,
const weight_t_of< ValueSet > &  w,
const typename ValueSet::value_t &  r 
) -> decltype(rs.lweight(w, r))
template<Automaton Aut, typename Tag = auto_tag>
Aut& vcsn::lweight_here ( const weight_t_of< Aut > &  w,
Aut &  res,
Tag  tag = {} 
)

In place left-multiplication of an automaton by a weight.

Definition at line 118 of file weight.hh.

Referenced by vcsn::rat::expansionset< expressionset_t >::lweight(), and vcsn::dyn::detail::lweight_tag().

template<bool Lazy, std::size_t OutTape, std::size_t InTape, Automaton Lhs, Automaton Rhs>
auto vcsn::make_compose_automaton ( const Lhs &  lhs,
const Rhs &  rhs 
)

Definition at line 452 of file compose.hh.

References vcsn::detail::insplit().

Here is the call graph for this function:

template<typename Cont , typename Pred >
container_filter_range<Cont, Pred> vcsn::make_container_filter_range ( const Cont &  cont,
Pred  pred 
)
template<typename Ctx >
Ctx vcsn::make_context ( const std::string &  name)

Build a context from its name.

Definition at line 22 of file make-context.hh.

References require(), and res.

Referenced by has_twins_property(), join_weightset_expressionset(), join_weightset_polynomialset(), minimize(), vcsn::ctx::detail::register_functions(), and to_spontaneous().

Here is the call graph for this function:

template<typename LabelSet , typename WeightSet >
context<LabelSet, WeightSet> vcsn::make_context ( const LabelSet &  ls,
const WeightSet ws 
)

Shorthand to build a context.

Definition at line 146 of file context.hh.

template<Automaton AutIn, Automaton AutOut>
detail::copier<AutIn, AutOut> vcsn::make_copier ( const AutIn &  in,
AutOut &  out,
bool  safe = true 
)

Build an automaton copier.

Parameters
ininput automaton, to copy
outoutput automaton, the destination
safewhether the input automaton is in normal form, i.e., never has two transitions with same (src, label, dst).

Definition at line 256 of file copy.hh.

References vcsn::detail::in(), and vcsn::detail::out().

Referenced by conjugate(), copy(), copy_into(), eliminate_state(), vcsn::detail::epsilon_remover_distance< Aut, has_one >::epsilon_remover_distance(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::epsilon_remover_separate(), and multiply_here().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::make_delay_automaton ( const Aut &  aut) -> decltype(detail::make_delay_automaton(aut))

Check whether the transducer is synchronized.

Parameters
[in]autthe transducer
Returns
whether it is synchronized

Definition at line 337 of file is-synchronized.hh.

template<typename ExpSet >
auto vcsn::make_derived_term_automaton ( const ExpSet &  rs,
const detail::derived_term_algo algo 
) -> derived_term_automaton<ExpSet>

Definition at line 319 of file derived-term.hh.

References vcsn::detail::rs.

Referenced by vcsn::dyn::derived_term(), and derived_term().

template<typename Container >
dynamic_bitset vcsn::make_dynamic_bitset ( const Container &  c,
size_t  size 
)

Definition at line 39 of file dynamic_bitset.hh.

References res.

template<typename Context >
expansionset<expressionset<Context> > vcsn::make_expansionset ( const expressionset< Context > &  es)

Definition at line 834 of file expansionset.hh.

Referenced by join_weightset_expansionset().

template<typename LabelSet , typename WeightSet >
auto vcsn::make_expressionset ( const context< LabelSet, WeightSet > &  ctx,
rat::identities  ids = {} 
) -> expressionset<context<LabelSet, WeightSet>>
template<typename Context >
auto vcsn::make_expressionset ( const expressionset< Context > &  rs,
rat::identities  ids = {} 
) -> expressionset<Context>

Shorthand to expressionset constructor.

Definition at line 609 of file expressionset.hh.

template<Automaton AutIn, Automaton AutOut = fresh_automaton_t_of<AutIn>>
AutOut vcsn::make_fresh_automaton ( const AutIn &  model)

Create an empty, mutable, automaton, based on another one.

To this end, each automaton type provides a fresh_automaton_t. In the case of mutable_automaton, it's simply mutable_automaton. In the case of a transpose_automaton<Aut>, it's transpose_automaton (of the fresh_automaton of Aut) so that we also create a transposed automaton. In the case of decorator, it's the base type, as we don't copy decorations.

Definition at line 91 of file copy.hh.

References vcsn::detail::real_context().

Referenced by aut_of_component(), conjunction(), vcsn::detail::quotienter< Aut >::operator()(), vcsn::detail::universal_impl< Aut >::work_(), and vcsn::detail::standard_operations< Aut >::zero_here().

Here is the call graph for this function:

template<typename Context >
auto vcsn::make_nullable_automaton ( const Context &  ctx)

Definition at line 881 of file mutable-automaton.hh.

References make_mutable_automaton(), and vcsn::detail::make_nullableset_context().

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::ldivide(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::rdivide(), and subword().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::make_partition_automaton ( const fresh_automaton_t_of< Aut > &  res,
const Aut &  input,
const typename detail::partition_automaton_impl< Aut >::origins_t  origins 
) -> partition_automaton_t<Aut>

Build a partition_automaton.

Parameters
resthe actual result, typically a mutable_automaton
inputthe automaton from which the partition is computed
originsmap each state of res to its states in input

Definition at line 212 of file partition-automaton.hh.

Referenced by vcsn::detail::quotienter< Aut >::operator()().

template<Automaton Aut>
auto vcsn::make_partition_automaton ( const fresh_automaton_t_of< Aut > &  res,
const partition_automaton< Aut > &  input,
const typename detail::partition_automaton_impl< Aut >::origins_t  origins 
) -> partition_automaton_t<Aut>

Build a partition_automaton of a partition_automaton: smash into a single level partition_automaton.

Parameters
resthe actual result, typically a mutable_automaton
inputthe automaton from which the partition is computed
originsmap each state of res to its states in input

Definition at line 228 of file partition-automaton.hh.

template<Automaton Aut>
auto vcsn::make_partition_automaton ( const fresh_automaton_t_of< transpose_automaton< Aut >> &  res,
const transpose_automaton< Aut > &  input,
const typename detail::partition_automaton_impl< Aut >::origins_t  origins 
) -> transpose_automaton<partition_automaton_t<Aut>>

Build a partition_automaton of a transpose_automaton: smash into a transpose_automaton of a partition_automaton.

Parameters
resthe actual result, typically a mutable_automaton
inputthe automaton from which the partition is computed
originsmap each state of res to its states in input

Definition at line 254 of file partition-automaton.hh.

std::mt19937 & vcsn::make_random_engine ( )

Generate a unique random device.

Definition at line 6 of file random.cc.

References res.

Referenced by random_automaton_deterministic().

template<typename RandomGenerator >
random_selector<RandomGenerator> vcsn::make_random_selector ( RandomGenerator &  g)

Definition at line 102 of file random.hh.

Referenced by random_label().

template<typename SharedPtr , typename... Args>
SharedPtr vcsn::make_shared_ptr ( Args &&...  args)

Same as std::make_shared, but parameterized by the shared_ptr type, not the (pointed to) element_type.

Definition at line 13 of file memory.hh.

template<Automaton... Auts>
auto vcsn::make_tuple_automaton ( const Auts &...  auts) -> tuple_automaton<Auts...>
template<typename T >
auto vcsn::make_unordered_pair ( T &&  e1,
T &&  e2 
)

Definition at line 34 of file pair.hh.

Referenced by vcsn::detail::pair_automaton_impl< Aut >::state_().

template<typename ValueSet >
auto vcsn::meet ( const ValueSet &  vs) -> ValueSet

The meet of a single valueset.

Useful for variadic operator on a single argument.

Definition at line 169 of file context.hh.

template<typename ValueSet1 , typename ValueSet2 , typename ValueSet3 , typename... VSs>
auto vcsn::meet ( const ValueSet1 &  vs1,
const ValueSet2 &  vs2,
const ValueSet3 &  vs3,
const VSs &...  vs 
) -> decltype(meet(meet(vs1, vs2), vs3, vs...))

Definition at line 178 of file context.hh.

References meet().

Here is the call graph for this function:

template<typename LhsLabelSet , typename LhsWeightSet , typename RhsLabelSet , typename RhsWeightSet >
auto vcsn::meet ( const context< LhsLabelSet, LhsWeightSet > &  a,
const context< RhsLabelSet, RhsWeightSet > &  b 
) -> context<meet_t<LhsLabelSet, RhsLabelSet>, join_t<LhsWeightSet, RhsWeightSet>>

The meet of two contexts.

Definition at line 221 of file context.hh.

References join(), and meet().

Here is the call graph for this function:

oneset vcsn::meet ( const oneset ,
const oneset  
)
inline

The meet of two labelsets.

Definition at line 247 of file oneset.hh.

template<typename GenSet >
letterset<GenSet> vcsn::meet ( const letterset< GenSet > &  lhs,
const letterset< GenSet > &  rhs 
)

Compute the meet with another labelset.

Definition at line 390 of file letterset.hh.

template<typename GenSet >
wordset<GenSet> vcsn::meet ( const wordset< GenSet > &  lhs,
const wordset< GenSet > &  rhs 
)

Compute the meet with another alphabet.

Definition at line 432 of file wordset.hh.

template<typename Ctx1 , typename Ctx2 >
auto vcsn::meet ( const expressionset< Ctx1 > &  a,
const expressionset< Ctx2 > &  b 
) -> expressionset<meet_t<Ctx1, Ctx2>>

The meet of two expressionsets.

Definition at line 619 of file expressionset.hh.

References vcsn::rat::meet().

Referenced by meet(), vcsn::detail::tupleset_impl< ValueSets >::meet_(), and vcsn::detail::meet_automata().

Here is the call graph for this function:

template<typename GenSet >
nullableset<letterset<GenSet> > vcsn::meet ( const nullableset< letterset< GenSet >> &  lhs,
const nullableset< letterset< GenSet >> &  rhs 
)

Compute the meet with another labelset.

Definition at line 711 of file nullableset.hh.

template<typename GenSet >
nullableset<letterset<GenSet> > vcsn::meet ( const letterset< GenSet > &  lhs,
const nullableset< letterset< GenSet >> &  rhs 
)

Definition at line 714 of file nullableset.hh.

template<typename GenSet >
nullableset<letterset<GenSet> > vcsn::meet ( const nullableset< letterset< GenSet >> &  lhs,
const letterset< GenSet > &  rhs 
)

Definition at line 717 of file nullableset.hh.

template<typename Lls , typename Rls >
nullableset<meet_t<Lls, Rls> > vcsn::meet ( const nullableset< Lls > &  lhs,
const nullableset< Rls > &  rhs 
)

Definition at line 721 of file nullableset.hh.

template<Automaton Aut, typename Tag >
auto vcsn::minimize ( const Aut &  a,
Tag   
) -> quotient_t<Aut>

Minimization via the minimizer functors.

Template Parameters
Autthe input automaton type.
Tagthe requested algorithm: moore_tag, signature_tag, weighted_tag.

Definition at line 24 of file minimize.hh.

References minimize(), and quotient().

Here is the call graph for this function:

template<Automaton Aut>
std::enable_if_t<is_free_boolean<Aut>), quotient_t<Aut> > vcsn::minimize ( const Aut &  a,
hopcroft_tag   
)

Definition at line 28 of file minimize-hopcroft.hh.

References bitset, vcsn::detail::ctx, vcsn::detail::in(), label_of(), make_context(), vcsn::detail::make_polynomialset(), vcsn::detail::make_vector(), quotient(), require(), res, set, vcsn::rat::size(), vcsn::detail::states_size(), and vcsn::detail::transform().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::minimize ( const Aut &  a,
brzozowski_tag   
) -> std::enable_if_t<is_free_boolean<Aut>(), determinized_automaton<codeterminized_automaton<Aut>, wet_kind_t::bitset>>

Brzozowski-based minimization.

Definition at line 30 of file minimize-brzozowski.hh.

References codeterminize(), and determinize().

Referenced by minimize(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
std::enable_if_t<std::is_same<weightset_t_of<Aut>, b>::value, quotient_t<Aut> > vcsn::minimize ( const Aut &  a,
auto_tag  = {} 
)

Minimization for Boolean automata: auto_tag.

Definition at line 35 of file minimize.hh.

template<Automaton Aut>
std::enable_if_t<!std::is_same<weightset_t_of<Aut>, b>::value, quotient_t<Aut> > vcsn::minimize ( const Aut &  a,
auto_tag  = {} 
)

Minimization for non Boolean automata: auto_tag..

Definition at line 44 of file minimize.hh.

template<Automaton Aut>
std::enable_if_t<is_free_boolean<Aut>), quotient_t<Aut> > vcsn::minimize ( const Aut &  a,
const std::string &  algo 
)

Minimization for Boolean automata on a free labelset: algo selection.

Parameters
athe automaton
algothe algorithm to run.

Definition at line 56 of file minimize.hh.

References minimize().

Here is the call graph for this function:

template<Automaton Aut>
std::enable_if_t<std::is_same<weightset_t_of<Aut>, b>::value && !labelset_t_of<Aut>::is_free(), quotient_t<Aut> > vcsn::minimize ( const Aut &  a,
const std::string &  algo 
)

Minimization for Boolean automata on a non-free labelset: algo selection.

Parameters
athe automaton
algothe algorithm to run.

Definition at line 83 of file minimize.hh.

References minimize().

Here is the call graph for this function:

template<Automaton Aut>
std::enable_if_t<!std::is_same<weightset_t_of<Aut>, b>::value, quotient_t<Aut> > vcsn::minimize ( const Aut &  a,
const std::string &  algo 
)

Minimization for non Boolean automata: algo selection.

Parameters
athe automaton
algothe algorithm to run.

Definition at line 105 of file minimize.hh.

References minimize().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2, typename Tag = general_tag>
auto vcsn::multiply ( const Aut1 &  lhs,
const Aut2 &  rhs,
Tag  tag = {} 
) -> decltype(lhs->null_state(), rhs->null_state(), detail::make_join_automaton(tag, lhs, rhs))
template<Automaton Aut, typename Tag = general_tag>
auto vcsn::multiply ( const Aut &  aut,
to  exp,
Tag  tag = {} 
) -> decltype(aut->null_state(), detail::make_join_automaton(tag, aut))

Repeated concatenation of an automaton.

Parameters
autthe automaton
expthe exponents

Definition at line 206 of file multiply.hh.

template<typename ValueSet >
ValueSet::value_t vcsn::multiply ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Product (concatenation) of expressions/labels/polynomials/weights.

Definition at line 280 of file multiply.hh.

template<typename ValueSet >
auto vcsn::multiply ( const ValueSet &  vs,
const typename ValueSet::value_t &  v,
const to exp 
) -> std::enable_if_t<!has_add_mem_fn<ValueSet>

Repeated multiplication of values that cannot be added.

Repeated multiplication of values that can be added.

Parameters
vsthe valueset
vthe value
expthe exponent, single.
vsthe valueset
vthe value
expthe exponent, composed of:
  • min the minimum number. If -1, denotes 0.
  • max the maximum number. If -1, denotes infinity, using star. If -2, denotes the same value as min.

Definition at line 345 of file multiply.hh.

Referenced by vcsn::dyn::detail::multiply_expression_repeated(), vcsn::dyn::detail::multiply_label_repeated(), vcsn::dyn::detail::multiply_weight(), and vcsn::dyn::detail::multiply_weight_repeated().

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::multiply_here ( Aut1 &  res,
const Aut2 &  b,
deterministic_tag   
)

Append automaton b to res.

Precondition
The context of res must include that of b.
The context of res is free.
Postcondition
The result is a deterministic automaton.

Definition at line 34 of file multiply.hh.

References determinize(), and res.

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::multiply_here ( Aut1 &  res,
const Aut2 &  b,
general_tag   
)

Append automaton b to res for non standard automata.

Precondition
The context of res must include that of b.

Definition at line 48 of file multiply.hh.

References copy(), vcsn::detail::final_transitions(), vcsn::detail::initial_transitions(), make_copier(), vcsn::detail::make_vector(), and res.

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::multiply_here ( Aut1 &  res,
const Aut2 &  b,
standard_tag  = {} 
)

Append automaton b to res.

Precondition
The context of res must include that of b.

Definition at line 89 of file multiply.hh.

template<Automaton Aut>
auto vcsn::normalize ( const Aut &  a) -> decltype(copy(a))

Normalize a automaton.

Definition at line 20 of file normalize.hh.

References costandard(), and standard().

Referenced by vcsn::rat::expansionset< expressionset_t >::ldivide(), and vcsn::rat::expansionset< expressionset_t >::ldivide_here().

Here is the call graph for this function:

template<Automaton Aut>
size_t vcsn::num_accessible_states ( const Aut &  a)

Number of accessible states, not counting pre() and post().

Definition at line 90 of file accessible.hh.

References accessible_states(), has(), res, and set.

Referenced by info(), is_accessible(), and num_coaccessible_states().

Here is the call graph for this function:

template<Automaton Aut>
size_t vcsn::num_coaccessible_states ( const Aut &  a)

Number of accessible states, not counting pre() and post().

Definition at line 105 of file accessible.hh.

References num_accessible_states(), and transpose().

Referenced by info(), and is_coaccessible().

Here is the call graph for this function:

template<Automaton Aut>
size_t vcsn::num_codeterministic_states ( const Aut &  aut)

Number of non-deterministic states of transposed automaton.

Definition at line 47 of file is-deterministic.hh.

References num_deterministic_states(), and transpose().

Referenced by info().

Here is the call graph for this function:

template<Automaton Aut>
std::size_t vcsn::num_components ( const scc_automaton< Aut > &  aut)

Get number of strongly connected components.

Definition at line 718 of file scc.hh.

Referenced by info().

template<Automaton Aut>
std::size_t vcsn::num_components ( const Aut &  )

Definition at line 724 of file scc.hh.

template<Automaton Aut>
size_t vcsn::num_deterministic_states ( const Aut &  aut)

Number of non-deterministic states.

Definition at line 33 of file is-deterministic.hh.

References is_deterministic(), and res.

Referenced by info(), and num_codeterministic_states().

Here is the call graph for this function:

template<typename Ctx >
constexpr auto vcsn::num_tapes ( const Ctx &  ) -> std::enable_if_t<Ctx::is_lat, size_t>

Definition at line 145 of file make-context.hh.

References vcsn::rat::size().

Referenced by vcsn::dyn::num_tapes(), and vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
size_t vcsn::num_useful_states ( const Aut &  a)

Number of accessible states, not counting pre() and post().

Definition at line 113 of file accessible.hh.

References has(), res, set, and useful_states().

Referenced by info(), is_trim(), and is_useless().

Here is the call graph for this function:

std::shared_ptr< std::istream > vcsn::open_input_file ( const std::string &  file)

Open file for reading and return its autoclosing stream.

Parameters
filethe file name. "-" and "" denote stdin.

Definition at line 134 of file stream.cc.

References res.

std::shared_ptr< std::ostream > vcsn::open_output_file ( const std::string &  file)

Open file for writing and return its autoclosing stream.

Parameters
filethe file name. "-" and "" denote stdout.

Definition at line 149 of file stream.cc.

References res.

std::string vcsn::operator+ ( symbol  l,
const char r 
)
inline

Definition at line 26 of file symbol.hh.

std::string vcsn::operator+ ( const char l,
symbol  r 
)
inline

Definition at line 32 of file symbol.hh.

std::string vcsn::operator+ ( symbol  l,
const std::string &  r 
)
inline

Definition at line 38 of file symbol.hh.

std::string vcsn::operator+ ( const std::string &  l,
symbol  r 
)
inline

Definition at line 44 of file symbol.hh.

bool vcsn::operator< ( empty_t  ,
empty_t   
)
inline

Definition at line 14 of file empty.hh.

std::ostream & vcsn::operator<< ( std::ostream &  os,
direction  d 
)

Pretty-printing.

Definition at line 19 of file direction.cc.

References to_string().

Here is the call graph for this function:

std::ostream & vcsn::operator<< ( std::ostream &  o,
const iomanipulator g 
)
inline

Launch the iomanipulator action on o.

Call the operator() of g(so set, get or swap the xalloced data with data_).

Definition at line 14 of file xalloc.hxx.

std::ostream & vcsn::operator<< ( std::ostream &  os,
const signature sig 
)

Output a string, escaping special characters.

Definition at line 17 of file signature.cc.

References os, and vcsn::signature::sig.

std::ostream& vcsn::operator<< ( std::ostream &  o,
const to t 
)
inline

Definition at line 72 of file to.hh.

References vcsn::to::max, and vcsn::to::min.

std::ostream & vcsn::operator<< ( std::ostream &  o,
const path p 
)
inline

Dump p on o.

Definition at line 42 of file path.hxx.

References vcsn::path::dump().

Here is the call graph for this function:

std::ostream & vcsn::operator<< ( std::ostream &  os,
format  i 
)

Output in string form.

Definition at line 49 of file format.cc.

References to_string().

Here is the call graph for this function:

std::ostream & vcsn::operator<< ( std::ostream &  o,
const file_library l 
)
inline

Print l on o.

Definition at line 103 of file file-library.hxx.

References vcsn::file_library::dump().

Here is the call graph for this function:

bool vcsn::operator== ( empty_t  ,
empty_t   
)
inline

Definition at line 21 of file empty.hh.

std::istream & vcsn::operator>> ( std::istream &  is,
direction d 
)

Parsing.

Definition at line 24 of file direction.cc.

References backward, eat(), fail_reading(), and forward.

Here is the call graph for this function:

std::istream & vcsn::operator>> ( std::istream &  is,
format i 
)

Read from string form.

Definition at line 54 of file format.cc.

template<Automaton Aut>
fresh_automaton_t_of<Aut, partial_identity_context_t_of<Aut> > vcsn::partial_identity ( const Aut &  aut)

Create a partial identity transducer from aut.

Definition at line 40 of file partial-identity.hh.

References vcsn::detail::all_transitions(), res, and vcsn::detail::states_size().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::path_monomial ( const Aut &  aut,
const std::vector< transition_t_of< Aut >> &  path,
state_t_of< Aut >  src = Aut::element_type::pre(),
state_t_of< Aut >  dst = Aut::element_type::post() 
) -> boost::optional<typename detail::word_polynomialset_t<context_t_of<Aut>>::monomial_t>

Given a path (typically computed by lightest_path), the corresponding monomial (label, weight).

Returns
boost::none if there is no path from src to dst.

Definition at line 76 of file lightest-path.hh.

References vcsn::detail::make_word_polynomialset().

Referenced by lightest(), and vcsn::detail::yen_impl< Aut, ValueSet, Mul, GetValue >::operator()().

Here is the call graph for this function:

template<Automaton Aut>
std::unordered_map<state_t_of<Aut>, std::pair<unsigned, transition_t_of<Aut> > > vcsn::paths_ibfs ( const Aut &  aut,
const std::vector< state_t_of< Aut >> &  start 
)

Find the shortest paths from some states to all the states.

Parameters
autthe automaton to traverse.
startthe states from which we reach the order states.
Returns
a map that, for each state, gives a pair: the shortest distance to its parent, and the transition id that allows to reach it.

Definition at line 72 of file distance.hh.

References vcsn::detail::all_in(), and vcsn::detail::make_queue().

Referenced by vcsn::detail::word_synchronizer< Aut >::init_pair().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::prefix ( const Aut &  aut) -> decltype(::vcsn::copy(aut))

Definition at line 69 of file prefix.hh.

References copy(), prefix_here(), and res.

Referenced by vcsn::ast::context_parser::automaton_(), and vcsn::detail::synchronizer< Aut >::get_prefix().

Here is the call graph for this function:

template<Automaton Aut>
Aut& vcsn::prefix_here ( Aut &  aut)

Make all coaccessible states final.

Definition at line 60 of file prefix.hh.

References suffix_here(), and transpose().

Referenced by factor_here(), and prefix().

Here is the call graph for this function:

template<typename T , typename Compare , typename Alloc >
std::ostream & vcsn::print ( const std::set< T, Compare, Alloc > &  set,
std::ostream &  o 
)

Print with a separator. Meant to help debugging.

Definition at line 35 of file set.hxx.

template<Automaton Aut>
std::ostream& vcsn::print ( const Aut &  aut,
std::ostream &  out = std::cout,
const std::string &  fmt = "default" 
)
template<typename ValueSet >
std::ostream& vcsn::print ( const ValueSet &  vs,
const typename ValueSet::value_t &  v,
std::ostream &  o = std::cout,
format  fmt = {} 
)

Print a value thanks to a valueset.

Applies for expansions, expressions, labels, polynomials, and weights. Beware that because of this, the fmt ought to specify whether to print for labels or for weights.

Definition at line 160 of file print.hh.

template<typename Context >
std::ostream& vcsn::print ( const expressionset< Context > &  rs,
const typename expressionset< Context >::value_t &  r,
std::ostream &  o = std::cout,
const std::string &  fmt = "default" 
)

Print an expression.

Definition at line 189 of file print.hh.

References vcsn::rat::make_dot_printer(), and print().

Here is the call graph for this function:

template<std::size_t Tape, Automaton Aut>
auto vcsn::project ( const Aut &  aut) -> mutable_automaton<detail::project_context<Tape, context_t_of<Aut>>>

Definition at line 18 of file project-automaton.hh.

References copy_into(), make_mutable_automaton(), and res.

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::proper ( const Aut &  aut,
direction  dir = direction::backward,
bool  prune = true,
const std::string &  algo = "auto" 
) -> fresh_automaton_t_of<Aut, detail::proper_context<context_t_of<Aut>>>

Eliminate spontaneous transitions.

Raise if the input automaton is invalid.

Parameters
autthe input automaton
dirwhether backward or forward elimination
prunewhether to suppress states becoming inaccessible
algohow elimination is performed "auto" same as "inplace" "default" same as "inplace" "inplace" eliminate in place "separate" first separate the automaton into spontaneous and proper parts "distance" compute all-pairs distances

Definition at line 244 of file proper.hh.

References backward, BUILTIN_UNREACHABLE, forward, vcsn::detail::make_properer(), and transpose().

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::complement(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::ldivide(), vcsn::automatonset< context_t_of< automaton_t >, tag_t >::rdivide(), realtime(), vcsn::ctx::detail::register_automaton_functions(), and weight_series().

Here is the call graph for this function:

template<Automaton Aut>
void vcsn::proper_here ( Aut &  aut,
direction  dir = direction::backward,
bool  prune = true,
const std::string &  algo = "auto" 
)

Eliminate spontaneous transitions in place.

Raise if the automaton was not valid.

Parameters
autthe input automaton
dirwhether backward or forward elimination
prunewhether to suppress states becoming inaccessible
algothe algorithm to use

Definition at line 278 of file proper.hh.

References backward, forward, vcsn::detail::make_properer(), and transpose().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::proper_lazy ( const Aut &  aut,
direction  dir = direction::backward,
bool  prune = true 
) -> lazy_proper_automaton<Aut>

Definition at line 261 of file proper.hh.

References backward, and require().

Referenced by vcsn::dyn::proper().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::push_weights ( const Aut &  aut) -> decltype(::vcsn::copy(aut))

The algorithm weight pushing.

1) Calculate shortest distance each state s to final states. 2) Update the weight of each transition by using shortest distance.

Definition at line 44 of file push-weights.hh.

References vcsn::detail::all_transitions(), copy(), res, and shortest_distance_to_finals().

Referenced by vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::quotient ( const Aut &  a,
typename detail::quotienter< Aut >::class_to_set_t &  cs 
) -> quotient_t<Aut>

Definition at line 123 of file quotient.hh.

Referenced by minimize().

template<typename Context >
mutable_automaton<Context> vcsn::quotkbaseb ( const Context &  ctx,
unsigned  divisor,
unsigned  base 
)

Build the transducer which accepts a word n representing a number in base "base" and outputs the quotient of the division of n by k.

Definition at line 17 of file quotkbaseb.hh.

References vcsn::detail::ctx, vcsn::detail::make_vector(), require(), res, and VCSN_REQUIRE.

Here is the call graph for this function:

template<typename... Args>
ATTRIBUTE_NORETURN void vcsn::raise ( Args &&...  args)

Raise a runtime_error with the concatenation of args as message.

Definition at line 75 of file raise.hh.

References vcsn::detail::print_(), and vcsn::detail::void.

Here is the call graph for this function:

template<typename WeightSet >
ATTRIBUTE_NORETURN void vcsn::raise_not_starrable ( const WeightSet ws,
const typename WeightSet::value_t &  w 
)

This value is not starrable.

Definition at line 100 of file raise.hh.

References to_string().

Referenced by vcsn::detail::min_plus_impl< zmin_impl, int >::star(), vcsn::detail::f2_impl::star(), vcsn::detail::log_impl::star(), vcsn::detail::qmp_impl::star(), vcsn::detail::r_impl::star(), vcsn::detail::z_impl::star(), vcsn::detail::q_impl::star(), and vcsn::detail::polynomialset_impl< Context, Kind >::star().

Here is the call graph for this function:

template<typename Ctx >
mutable_automaton<Ctx> vcsn::random_automaton ( const Ctx &  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 = "" 
)

Produce a random automaton.

Parameters
ctxThe context of the result.
num_statesThe number of states wanted in the automata (>0). All states will be connected, and there will be no dead state. However, some might not be coaccessible.
densityThe density of the automata. This is the probability (between 0.0 and 1.0), to add a transition between two states. All states have at least one outgoing transition, so d is considered only when adding the remaining transition. A density of 1 means all states will be connected to each other.
num_initialThe number of initial states wanted (0 <= num_initial <= num_states)
num_finalThe number of final states wanted (0 <= num_final <= num_states)
max_labelsThe maximum number of labels per transition. Defaults to the number of generators.
loop_chanceThe probability (between 0.0 and 1.0) for each state to have a loop.
weightsThe specification string (following the format of random_weight) used to generate weights on each transitions.

Definition at line 45 of file random-automaton.hh.

Referenced by vcsn::dyn::random_automaton().

template<typename Ctx >
mutable_automaton<Ctx> vcsn::random_automaton_deterministic ( const Ctx &  ctx,
unsigned  num_states 
)

Definition at line 241 of file random-automaton.hh.

References vcsn::detail::ctx, vcsn::detail::irange(), make_random_engine(), require(), and res.

Referenced by vcsn::dyn::random_automaton_deterministic().

Here is the call graph for this function:

template<typename ExpressionSet >
ExpressionSet::value_t vcsn::random_expression ( const ExpressionSet &  rs,
const std::string &  param 
)

Generate a random expression.

Definition at line 274 of file random-expression.hh.

References vcsn::detail::make_random_expression_impl().

Here is the call graph for this function:

template<typename ExpressionSet >
std::string vcsn::random_expression_string ( const ExpressionSet &  rs,
const std::string &  param 
)

Generate a random expression string.

Return a string. This allows doing easily constructs that are not possible in the AST in case we want them (i.e [a-z] ranges). Furthermore, the user can then choose the identities they want to apply to the resulting expression.

Definition at line 264 of file random-expression.hh.

References vcsn::detail::make_random_expression_impl().

Here is the call graph for this function:

template<typename RandomGenerator = std::default_random_engine>
oneset::value_t vcsn::random_label ( const oneset ls,
RandomGenerator &  = RandomGenerator() 
)

Random label from oneset.

Definition at line 255 of file oneset.hh.

References vcsn::oneset::one().

Here is the call graph for this function:

template<typename GenSet , typename RandomGenerator = std::default_random_engine>
wordset<GenSet>::value_t vcsn::random_label ( const wordset< GenSet > &  ls,
RandomGenerator &  gen = RandomGenerator() 
)

Random label from wordset.

Definition at line 446 of file wordset.hh.

template<typename LabelSet , typename RandomGenerator = std::default_random_engine>
LabelSet::value_t vcsn::random_label ( const LabelSet &  ls,
RandomGenerator &  gen = RandomGenerator() 
)

Random label from general case such as letterset.

Definition at line 457 of file labelset.hh.

References make_random_selector(), and require().

Here is the call graph for this function:

template<typename Context , typename RandomGenerator = std::default_random_engine>
expressionset<Context>::value_t vcsn::random_label ( const expressionset< Context > &  rs,
RandomGenerator &  gen = RandomGenerator() 
)

Random label from expressionset: limited to a single label.

Definition at line 635 of file expressionset.hh.

Referenced by vcsn::detail::random_expression_impl< ExpressionSet, RandomGenerator >::print_label_(), and random_label_().

template<typename LabelSet , typename RandomGenerator = std::default_random_engine>
nullableset<LabelSet>::value_t vcsn::random_label ( const nullableset< LabelSet > &  ls,
RandomGenerator &  gen = RandomGenerator() 
)

Random label from nullableset.

Definition at line 738 of file nullableset.hh.

template<typename... LabelSet, typename RandomGenerator = std::default_random_engine>
tupleset<LabelSet...>::value_t vcsn::random_label ( const tupleset< LabelSet... > &  ls,
RandomGenerator &  gen = RandomGenerator() 
)

Random label from tupleset.

Definition at line 1381 of file tupleset.hh.

References random_label_().

Here is the call graph for this function:

template<typename... LabelSet, size_t... I, typename RandomGenerator = std::default_random_engine>
tupleset<LabelSet...>::value_t vcsn::random_label_ ( const tupleset< LabelSet... > &  ls,
RandomGenerator &  gen,
detail::index_sequence< I... >   
)

Implementation detail for random label from tupleset.

Definition at line 1393 of file tupleset.hh.

References random_label().

Referenced by random_label().

Here is the call graph for this function:

template<typename WeightSet >
WeightSet::value_t vcsn::random_weight ( const WeightSet ws,
const std::string &  param = {} 
)

Generate a random weight.

Definition at line 15 of file random-weight.hh.

template<typename ValueSet >
ValueSet::value_t vcsn::rdivide ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)

Right-division of values.

Definition at line 123 of file divide.hh.

template<Automaton Aut1, Automaton Aut2>
auto vcsn::rdivide ( const Aut1 &  a1,
const Aut2 &  a2 
)

Compute the right quotient.

Parameters
a1left hand side
a2right hand side

Definition at line 753 of file conjunction.hh.

References vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::ldivide(), and transpose().

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::rdivide(), and vcsn::dyn::rdivide().

Here is the call graph for this function:

template<typename Context >
auto vcsn::read_label ( const Context &  ctx,
std::istream &  is,
bool  quoted = false 
) -> label_t_of<Context>

Definition at line 17 of file read.hh.

References vcsn::detail::ctx.

Referenced by vcsn::ctx::detail::register_functions().

template<typename Context >
auto vcsn::read_polynomial ( const Context &  ctx,
std::istream &  is 
) -> typename polynomialset<Context>::value_t

Definition at line 47 of file read.hh.

References conv(), and vcsn::detail::ctx.

Referenced by vcsn::ctx::detail::register_functions().

Here is the call graph for this function:

template<typename Context >
auto vcsn::read_weight ( const Context &  ctx,
std::istream &  is 
) -> weight_t_of<Context>

Definition at line 77 of file read.hh.

References vcsn::detail::ctx.

Referenced by vcsn::ctx::detail::register_functions().

template<Automaton Aut>
auto vcsn::realtime ( const Aut &  aut) -> decltype(proper(::vcsn::letterize(aut)))

Split the word transitions in the input automaton into letter ones, and remove the spontaneous transitions.

Parameters
[in]autthe automaton
Returns
the realtime automaton

Definition at line 219 of file letterize.hh.

References letterize(), and proper().

Referenced by are_equivalent().

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::reduce ( const Aut &  input) -> decltype(copy(input))

Definition at line 608 of file reduce.hh.

References left_reduce(), and transpose().

Here is the call graph for this function:

template<typename Bool , typename... Args>
void vcsn::require ( Bool  b,
Args &&...  args 
)

If b is not verified, raise an error with args as message.

Beware that the arguments are, of course, always evaluated. So avoid passing costly function calls. See VCSN_REQUIRE.

Definition at line 91 of file raise.hh.

Referenced by vcsn::edit_automaton< Aut >::add_entry(), add_here(), vcsn::detail::is_ambiguous_impl< Aut >::ambiguous_word(), ambiguous_word(), cerny(), vcsn::rat::expansionset< expressionset_t >::complement_(), complement_here(), vcsn::rat::to_expansion_visitor< expressionset_t >::compose(), conjugate(), conjunction(), vcsn::detail::f2_impl::conv(), vcsn::oneset::conv(), vcsn::detail::b_impl::conv(), vcsn::letterset< GenSet >::conv(), vcsn::detail::q_impl::conv(), vcsn::detail::polynomialset_impl< Context, Kind >::conv(), vcsn::detail::conv_label_class_(), vcsn::detail::polynomialset_impl< Context, Kind >::conv_monomial(), de_bruijn(), derivation(), vcsn::dyn::derived_term(), derived_term(), vcsn::detail::word_synchronizer< Aut >::dest_state(), vcsn::detail::dispatch_tags(), divkbaseb(), double_ring(), eliminate_state(), evaluate(), vcsn::rat::expressionset_impl< Context >::expressionset_impl(), vcsn::detail::gcd(), vcsn::ast::context_parser::genset_(), get_char(), vcsn::are_isomorphicer< Aut1, Aut2 >::get_full_response(), vcsn::detail::pair_automaton_impl< Aut >::get_origin(), vcsn::set_alphabet< L >::get_word(), has_twins_property(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::infiltrate(), vcsn::detail::word_synchronizer< Aut >::init_synchro(), is_synchronized_by(), ladybird(), vcsn::rat::expressionset_impl< Context >::letter_class_(), vcsn::detail::z_impl::lgcd(), vcsn::detail::b_impl::lgcd(), vcsn::detail::r_impl::lgcd(), vcsn::detail::q_impl::lgcd(), lightest_path(), vcsn::detail::standard_operations< Aut >::lweight_here(), make_context(), vcsn::rat::driver::make_label(), vcsn::rat::driver::make_weight(), minimize(), vcsn::detail::minimizer< Aut, moore_tag >::minimizer(), vcsn::detail::minimizer< Aut, weighted_tag >::minimizer(), vcsn::detail::minimizer< Aut, signature_tag >::minimizer(), vcsn::detail::lightest_impl< Aut >::operator()(), vcsn::detail::state_eliminator< Aut, Profiler >::operator()(), vcsn::are_isomorphicer< Aut1, Aut2 >::origins(), vcsn::detail::dot::driver::parse(), vcsn::detail::dot::parser::parse(), proper_lazy(), vcsn::detail::properer< Aut >::proper_star_(), vcsn::detail::properer< Aut >::proper_star_here_(), quotkbaseb(), random_automaton_deterministic(), random_label(), vcsn::detail::min_plus_impl< zmin_impl, int >::rdivide(), vcsn::detail::f2_impl::rdivide(), vcsn::detail::log_impl::rdivide(), vcsn::detail::qmp_impl::rdivide(), vcsn::detail::z_impl::rdivide(), vcsn::detail::b_impl::rdivide(), vcsn::detail::r_impl::rdivide(), vcsn::detail::q_impl::rdivide(), vcsn::dyn::read_daut(), vcsn::dyn::read_efsm(), vcsn::dyn::read_fado(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::shuffle(), star_here(), and u().

std::ostream & vcsn::resetindent ( std::ostream &  o)

Reset the indentation.

Definition at line 34 of file indent.cc.

References vcsn::detail::indentation.

template<Automaton Aut>
std::vector<state_t_of<Aut> > vcsn::reverse_postorder ( const Aut &  aut)

Get all states in reverse postorder.

Definition at line 98 of file scc.hh.

References vcsn::detail::reverse_postorder_impl< Aut >::reverse_post().

Here is the call graph for this function:

template<Automaton Aut, typename Tag = auto_tag>
fresh_automaton_t_of<Aut> vcsn::rweight ( const Aut &  aut,
const weight_t_of< Aut > &  w,
Tag  tag = {} 
)

Right-multiplication of an automaton by a weight.

Definition at line 329 of file weight.hh.

Referenced by info().

template<typename ValueSet >
ValueSet::value_t vcsn::rweight ( const ValueSet &  rs,
const typename ValueSet::value_t &  r,
const weight_t_of< ValueSet > &  w 
)
template<Automaton Aut, typename Tag = auto_tag>
Aut& vcsn::rweight_here ( Aut &  res,
const weight_t_of< Aut > &  w,
Tag  tag = {} 
)

In place right-multiplication of an automaton by a weight.

Definition at line 321 of file weight.hh.

Referenced by vcsn::dyn::detail::rweight_tag().

template<typename Container >
bool vcsn::same_domain ( const Container &  x,
const Container &  y 
)

Check that two associative containers have the same keys.

Definition at line 195 of file algorithm.hh.

template<Automaton Aut>
scc_automaton<Aut> vcsn::scc ( const Aut &  aut,
const std::string &  algo = "auto" 
)

Get scc_automaton from aut.

Definition at line 693 of file scc.hh.

Referenced by vcsn::detail::scc_impl< Aut, dijkstra_tag >::dfs(), and info().

scc_algo_t vcsn::scc_algo ( const std::string &  algo)
inline

Definition at line 515 of file scc.hh.

References auto_, dijkstra, kosaraju, tarjan_iterative, and tarjan_recursive.

template<typename Container , typename = typename Container::value_type>
Container vcsn::set_difference ( const Container &