Vcsn  2.2a
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...
 
class  are_isomorphicer
 
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  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
 
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 >
 
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...
 
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::automata> -> std::tuple<automaton_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< 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  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<bool Lazy, Automaton Aut, Automaton... Auts>
using product_automaton = std::shared_ptr< detail::product_automaton_impl< Lazy, Aut, Auts... >>
 A product 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>
using filter_automaton = std::shared_ptr< detail::filter_automaton_impl< Aut >>
 
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 = std::shared_ptr< detail::insplit_automaton_impl< Aut, labelset_t_of< Aut >::has_one()>>
 A compose 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<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 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>
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))
 
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 (Lhs &lhs, 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 (Lhs &lhs, Rhs &rhs)
 Build the (accessible part of the) laze composition. More...
 
template<Automaton Aut>
Aut conjugate (const Aut &aut)
 
template<bool Lazy, Automaton Aut, Automaton... Auts>
auto make_product_automaton (Aut aut, const Auts &...auts) -> product_automaton< Lazy, Aut, Auts... >
 
template<Automaton... Auts>
auto conjunction (const Auts &...as) -> tuple_automaton< decltype(meet_automata(as...)), Auts... >
 Build the (accessible part of the) conjunction. More...
 
template<Automaton... Auts>
auto conjunction_lazy (const Auts &...as) -> product_automaton< true, decltype(meet_automata(as...)), Auts... >
 Build the (accessible part of the) conjunction, on-the-fly. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut2 & ldiv_here (const Aut1 &lhs, Aut2 &res)
 Compute the left quotient in place. More...
 
template<Automaton Aut1, Automaton Aut2>
auto ldiv (const Aut1 &a1, const Aut2 &a2)
 Compute the left quotient. More...
 
template<Automaton Aut1, Automaton Aut2>
auto rdiv (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 infiltration (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 infiltration (const A1 &a1, const A2 &a2, const A3 &a3, const Auts &...as) -> decltype(infiltration(infiltration(a1, a2), a3, as...))
 The (accessible part of the) infiltration product. More...
 
template<typename ValueSet >
ValueSet::value_t infiltration (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, unsigned n) -> fresh_automaton_t_of< Aut >
 
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<typename Context >
mutable_automaton< Context > de_bruijn (const Context &ctx, unsigned n)
 
template<Automaton Aut>
auto make_delay_automaton (const Aut &aut) -> decltype(detail::make_delay_automaton(aut))
 Check whether the transducer is synchronized. More...
 
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>> ::value>>
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_free(), 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 free labelsets. More...
 
template<typename ExpSet >
std::enable_if_t<!labelset_t_of< ExpSet >::is_free(), 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 free 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 ldiv (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 rdiv (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, format fmt={})
 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)
 Format automaton to EFSM format, based on FSM format. More...
 
template<Automaton Aut>
auto eval (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 eval (const Aut &a) -> std::enable_if_t< context_t_of< Aut >::is_lao, weight_t_of< Aut >>
 Evaluation for lao automaton. More...
 
template<typename ExpSet >
ExpSet::value_t expand (const ExpSet &rs, const typename ExpSet::value_t &e)
 Expand a typed expression. More...
 
template<Automaton Aut>
filter_automaton< Aut > filter (const Aut &aut, const std::unordered_set< state_t_of< Aut >> &ss)
 Get an automaton who is a part state set ss of aut. More...
 
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)
 
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)
 
template<Automaton Aut>
std::ostream & grail (const Aut &aut, std::ostream &out)
 
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>
std::ostream & info (const Aut &aut, std::ostream &out, bool detailed=false)
 
template<typename ExpSet >
void info (const ExpSet &rs, const typename ExpSet::value_t &e, std::ostream &o)
 
template<Automaton Aut>
auto make_insplit_automaton (const Aut &aut) -> insplit_automaton< Aut >
 
template<Automaton Aut>
auto insplit_lazy (const Aut &aut) -> decltype(make_insplit_automaton(aut))
 
template<Automaton Aut>
auto insplit (const Aut &aut) -> decltype(detail::insplit(aut))
 
template<Automaton Aut>
bool is_ambiguous (const Aut &aut, std::tuple< state_t_of< Aut >, state_t_of< Aut >> &witness)
 Whether an automaton is ambiguous. More...
 
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 transpositive 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 transpositive automaton is deterministic. More...
 
template<Automaton Aut>
ATTRIBUTE_CONST bool is_eps_acyclic (const Aut &aut)
 
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<typename Context >
mutable_automaton< Context > ladybird (const Context &ctx, unsigned n)
 
template<Automaton Aut, typename Tag = auto_tag>
Aut & left_mult_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 left_mult (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 left_mult (const ValueSet &rs, const weight_t_of< ValueSet > &w, const typename ValueSet::value_t &r) -> decltype(rs.lmul(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<Automaton Aut, typename Tag = auto_tag>
Aut & right_mult_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 > right_mult (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 right_mult (const ValueSet &rs, const typename ValueSet::value_t &r, const weight_t_of< ValueSet > &w)
 
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, 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)
 
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(), 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, int min, int max, 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 ExpSet >
ExpSet::value_t multiply (const ExpSet &rs, const typename ExpSet::value_t &r, int min, int 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, const std::string &fmt)
 
template<typename ValueSet >
std::ostream & print (const ValueSet &vs, const typename ValueSet::value_t &v, std::ostream &o, 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, format fmt)
 Print an expression. More...
 
template<typename Context >
std::ostream & print (const expressionset< Context > &rs, const typename expressionset< Context >::value_t &r, std::ostream &o, const std::string &fmt)
 Print an expression. More...
 
template<typename PolynomialSet >
std::ostream & list (const PolynomialSet &ps, const typename PolynomialSet::value_t &p, std::ostream &o)
 
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 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 , 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 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 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...
 
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 Ctx >
mutable_automaton< Ctx > random_automaton (const Ctx &ctx, unsigned num_states, float density=0.1, unsigned num_initial=1, unsigned num_final=1, float loop_chance=0.0)
 
template<typename Ctx >
mutable_automaton< Ctx > random_automaton_deterministic (const Ctx &ctx, unsigned num_states)
 
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 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 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 Aut1, Automaton Aut2>
Aut1 & sum_here (Aut1 &res, const Aut2 &b, deterministic_tag)
 Merge transitions of b into those of res. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & sum_here (Aut1 &res, const Aut2 &b, standard_tag)
 Merge transitions of b into those of res. More...
 
template<Automaton Aut1, Automaton Aut2>
Aut1 & sum_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 sum (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 sum (const ValueSet &vs, const typename ValueSet::value_t &lhs, const typename ValueSet::value_t &rhs)
 Sums of values. 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())))>
 to_spontaneous More...
 
template<Automaton Aut>
Aut transpose (const transpose_automaton< Aut > &aut)
 
template<Automaton Aut>
transpose_automaton< Aut > transpose (Aut aut)
 
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 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 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 ExpSet >
expansionset< ExpSet > make_expansionset (const ExpSet &expset)
 
template<typename Context >
expressionset< Context > make_expressionset (const Context &ctx, rat::identities identities={})
 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 ExpSet >
ExpSet::value_t transpose (const ExpSet &rs, const typename ExpSet::value_t &v)
 A 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 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)
 
oneset meet (const oneset &, const oneset &)
 The meet of two labelsets. More...
 
template<typename GenSet >
wordset< GenSet > meet (const wordset< GenSet > &lhs, const wordset< GenSet > &rhs)
 Compute the meet with another alphabet. 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...
 
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...
 
std::string str_escape (const std::string &c, const char *special=nullptr)
 Likewise, but produces a string. More...
 
template<typename T >
std::string str_escape (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::string str_escape (int c, const char *special=nullptr)
 Likewise, but produces a string. More...
 
std::ostream & operator<< (std::ostream &o, const file_library &l)
 Print l on o. 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...
 
int address (const void *t)
 Name pointers, to make them easier to read. More...
 
template<typename T >
int address (T *t)
 
template<typename T >
int address (const T &t)
 
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 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 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...
 
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...
 
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::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...
 
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<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)
 
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

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

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 12 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 381 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 53 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 307 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 242 of file determinize.hh.

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

Definition at line 27 of file dynamic_bitset.hh.

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

Definition at line 203 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 200 of file fwd.hh.

Definition at line 49 of file fwd.hh.

template<Automaton Aut>
using vcsn::filter_automaton = typedef std::shared_ptr<detail::filter_automaton_impl<Aut>>

Definition at line 167 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 74 of file traits.hh.

template<Automaton Aut>
using vcsn::insplit_automaton = typedef std::shared_ptr<detail::insplit_automaton_impl<Aut, labelset_t_of<Aut>::has_one()>>

A compose automaton as a shared pointer.

Definition at line 312 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 54 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 55 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 78 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 244 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 33 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<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<bool Lazy, Automaton Aut, Automaton... Auts>
using vcsn::product_automaton = typedef std::shared_ptr<detail::product_automaton_impl<Lazy, Aut, Auts...>>

A product automaton as a shared pointer.

Definition at line 462 of file conjunction.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 56 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 57 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 278 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 32 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 58 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 59 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 848 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 859 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 82 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 9 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 503 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::dyn::accessible(), 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().

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

Here is the call graph for this function:

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

Definition at line 33 of file memory.hh.

References address().

Here is the call graph for this function:

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

Definition at line 40 of file memory.hh.

References address().

Here is the call graph for this function:

template<typename... Bool>
bool vcsn::all ( Bool &&...  values)
template<bool... B>
constexpr bool vcsn::all_ ( )

Definition at line 404 of file tuple.hh.

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

Definition at line 108 of file distance.hh.

References vcsn::detail::all_transitions().

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 66 of file is-ambiguous.hh.

References is_ambiguous(), lightest_path(), path_monomial(), 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 397 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 685 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(), and vcsn::detail::out().

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::rat::ctx(), and require().

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<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::dyn::coaccessible(), is_ambiguous(), 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_ambiguous(), is_partial_identity(), 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 364 of file determinize.hh.

Referenced by vcsn::dyn::detail::codeterminize_tag_(), and 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)
inline

Sum of bucket sizes.

Definition at line 13 of file unordered_map.hh.

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(), and copy().

Referenced by vcsn::dyn::complement(), 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))

Definition at line 61 of file complete.hh.

References complete_here(), and copy().

Referenced by vcsn::dyn::complete(), difference(), vcsn::detail::universaler< 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<Automaton Lhs, Automaton Rhs, std::size_t OutTape = 1, std::size_t InTape = 0>
auto vcsn::compose ( Lhs &  lhs,
Rhs &  rhs 
)

Build the (accessible part of the) composition.

Definition at line 404 of file compose.hh.

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

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

Build the (accessible part of the) laze composition.

Definition at line 415 of file compose.hh.

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 9 of file conjugate.hh.

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

Here is the call graph for this function:

template<Automaton... Auts>
auto vcsn::conjunction ( const Auts &...  as) -> tuple_automaton<decltype(meet_automata(as...)), Auts...>

Build the (accessible part of the) conjunction.

Definition at line 482 of file conjunction.hh.

References vcsn::detail::meet_automata().

Referenced by vcsn::dyn::detail::conjunction_(), vcsn::dyn::detail::conjunction_expression(), vcsn::dyn::detail::conjunction_polynomial(), vcsn::dyn::detail::conjunction_repeated(), difference(), has_twins_property(), info(), is_ambiguous(), and is_cycle_ambiguous_scc().

Here is the call graph for this function:

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

Definition at line 808 of file conjunction.hh.

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

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 869 of file conjunction.hh.

template<Automaton... Auts>
auto vcsn::conjunction_lazy ( const Auts &...  as) -> product_automaton<true, decltype(meet_automata(as...)), Auts...>

Build the (accessible part of the) conjunction, on-the-fly.

Definition at line 495 of file conjunction.hh.

References vcsn::detail::meet_automata().

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

Here is the call graph for this function:

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)...))
inline
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))
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 324 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 340 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 356 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 373 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 391 of file copy.hh.

References copy(), and make_copier().

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 260 of file copy.hh.

References copy(), and make_copier().

Referenced by copy_into(), vcsn::dyn::left_mult(), vcsn::detail::epsilon_remover< Aut, has_one >::operator()(), project(), vcsn::dyn::right_mult(), subword(), and sum_here().

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 271 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 282 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.

Precondition
AutIn <: AutOut.

Definition at line 294 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 124 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 227 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 286 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 280 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 287 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<typename Context >
mutable_automaton<Context> vcsn::de_bruijn ( const Context &  ctx,
unsigned  n 
)

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

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

Referenced by vcsn::dyn::de_bruijn(), 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 267 of file derivation.hh.

References 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 285 of file derivation.hh.

References derivation(), label_of(), vcsn::rat::make_expression_polynomialset(), 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>> ::value>>
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 314 of file derivation.hh.

References derivation(), and require().

Here is the call graph for this function:

template<typename ExpSet >
std::enable_if_t<labelset_t_of<ExpSet>::is_free(), 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 free labelsets.

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

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

References make_derived_term_automaton().

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

Here is the call graph for this function:

template<typename ExpSet >
std::enable_if_t<!labelset_t_of<ExpSet>::is_free(), 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 free labelsets.

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

Definition at line 344 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:

template<Automaton Aut, typename Tag , bool Lazy = false>
auto vcsn::determinize ( const Aut &  a,
Tag  = {},
bool_constant< Lazy >  = {} 
)
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 272 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(), and vcsn::dyn::difference().

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

Difference of expressions.

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

Referenced by 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 18 of file divkbaseb.hh.

References vcsn::rat::ctx(), require(), and VCSN_REQUIRE.

Referenced by vcsn::dyn::divkbaseb(), 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,
format  fmt = {} 
)

Print an automaton in Graphviz's Dot format.

Parameters
autthe automaton to print.
outthe output stream.
fmthow to format the automaton.

Definition at line 377 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 18 of file double-ring.hh.

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

Referenced by vcsn::dyn::double_ring(), 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 48 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 
)

Format automaton to EFSM format, based on FSM format.

Template Parameters
Autan automaton type.

Definition at line 346 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 448 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 435 of file to-expression.hh.

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

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 282 of file shortest.hh.

References shortest().

Here is the call graph for this function:

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

General case of evaluation.

Definition at line 101 of file eval.hh.

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

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

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 116 of file eval.hh.

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

Here is the call graph for this function:

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 &  e 
)
inline

Expand a typed expression.

Definition at line 151 of file expand.hh.

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

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

Definition at line 106 of file prefix.hh.

References copy(), and factor_here().

Referenced by vcsn::dyn::factor(), and vcsn::detail::polynomialset_impl< Context, Kind >::ldiv().

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 
)

Definition at line 204 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 
)
inline

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 62 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< unsigned int >::conv(), vcsn::detail::z_impl::conv(), eat(), and operator>>().

Here is the call graph for this function:

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

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

Definition at line 172 of file filter.hh.

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

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

Definition at line 319 of file focus.hh.

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

Read a single char, with possible -escape support.

EOF is an error.

Definition at line 78 of file stream.hh.

References require().

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 66 of file stream.cc.

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

Here is the call graph for this function:

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

Definition at line 272 of file grail.hh.

References vcsn::detail::out().

Here is the call graph for this function:

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 12 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 13 of file deque.hh.

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

Whether e is in s.

Definition at line 14 of file bimap.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::ast::context_parser::any_(), aut_of_component(), vcsn::detail::cycle_identity_impl< Aut >::check(), 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(), is_ambiguous(), vcsn::are_isomorphicer< Aut1, Aut2 >::is_isomorphism_valid_throwing(), vcsn::detail::insplit_automaton_impl< Aut, HasOne >::is_lazy(), is_partial_identity(), vcsn::ast::context_parser::labelset_or_weightset_(), vcsn::rat::expressionset_impl< Context >::letter_class_(), num_accessible_states(), num_useful_states(), vcsn::detail::a_star_impl< Aut >::operator()(), vcsn::detail::dotter< Aut >::print_state_(), vcsn::detail::dotter< Aut >::print_transitions_(), set_intersection(), ss_shortest_distance(), vcsn::detail::tuple_automaton_impl< Aut, Auts >::state_has_name(), vcsn::detail::pair_automaton_impl< Aut >::state_has_name(), vcsn::detail::polystate_automaton_impl< Aut, Kind, Lazy >::state_has_name(), vcsn::rat::standard_visitor< Aut, ExpSet >::VCSN_RAT_VISIT(), vcsn::ast::context_parser::weightset_(), and vcsn::detail::universaler< Aut >::work_().

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

Whether e is member of m.

Definition at line 26 of file unordered_map.hh.

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 27 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<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 148 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< bool, Dummy >::print_(), vcsn::rat::dot_printer< ExpSet >::print_(), and vcsn::ast::context_printer::visit().

Here is the call graph for this function:

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.

Referenced by vcsn::detail::universaler< 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 A1, Automaton A2>
auto vcsn::infiltration ( 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 724 of file conjunction.hh.

References vcsn::detail::join_automata().

Referenced by vcsn::dyn::detail::infiltration_(), vcsn::dyn::detail::infiltration_expression(), and info().

Here is the call graph for this function:

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

The (accessible part of the) infiltration product.

Definition at line 736 of file conjunction.hh.

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

Here is the call graph for this function:

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

Infiltration product of expressions.

Definition at line 776 of file conjunction.hh.

template<Automaton Aut>
std::ostream& vcsn::info ( const Aut &  aut,
std::ostream &  out,
bool  detailed = false 
)
template<typename ExpSet >
void vcsn::info ( const ExpSet &  rs,
const typename ExpSet::value_t &  e,
std::ostream &  o 
)

Definition at line 146 of file info.hh.

References complement(), conjunction(), ECHO, infiltration(), info(), ldiv(), shuffle(), vcsn::format::sname, star(), sum(), and tuple().

Here is the call graph for this function:

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

Definition at line 336 of file insplit.hh.

References vcsn::detail::insplit().

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

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::insplit_lazy ( const Aut &  aut) -> decltype(make_insplit_automaton(aut))
inline

Definition at line 325 of file insplit.hh.

References make_insplit_automaton().

Referenced by vcsn::dyn::insplit(), and make_compose_automaton().

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::universaler< 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>
bool vcsn::is_ambiguous ( const Aut &  aut,
std::tuple< state_t_of< Aut >, state_t_of< Aut >> &  witness 
)

Whether an automaton is ambiguous.

Parameters
[in]autthe automaton
[out]witnessif ambiguous, a pair of "ambiguous" states.
Returns
whether ambiguous.

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

References coaccessible(), coaccessible_states(), conjunction(), and has().

Here is the call graph for this function:

template<Automaton Aut>
bool vcsn::is_ambiguous ( const Aut &  aut)
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)
inline

Whether the transpositive 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 13 of file is-complete.hh.

References vcsn::detail::all_out().

Referenced by complement_here(), difference(), info(), vcsn::detail::universaler< 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 110 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 138 of file is-ambiguous.hh.

References 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 
)
inline

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::fadoer< Aut >::is_deterministic_(), vcsn::detail::minimizer< Aut, moore_tag >::minimizer(), num_deterministic_states(), vcsn::detail::universaler< 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)
inline

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>
bool vcsn::is_empty ( const Aut &  a)

Whether has no states.

Definition at line 192 of file accessible.hh.

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

template<Automaton Aut>
ATTRIBUTE_CONST bool vcsn::is_eps_acyclic ( const Aut &  aut)
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 191 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)
inline

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

Definition at line 60 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)
inline

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 48 of file is-proper.hh.

References vcsn::detail::is_proper_().

Referenced by eval(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover(), info(), is_realtime(), vcsn::detail::is_valider< Aut, has_one >::is_valid_(), and vcsn::ctx::detail::register_functions().

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 249 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 vcsn::detail::dispatch_tags(), info(), is_costandard(), is_normalized(), vcsn::detail::standard_operations< Aut >::left_mult_here(), vcsn::ctx::detail::register_functions(), standard_here(), star_here(), and sum_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 310 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)
inline

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

References vcsn::detail::is_valider< 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 17 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 203 of file left-mult.hh.

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

Referenced by vcsn::dyn::detail::left_mult_expansion(), and vcsn::dyn::detail::right_mult_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 258 of file left-mult.hh.

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

Referenced by join_weightset_expansionset(), vcsn::dyn::detail::left_mult_expression(), and vcsn::dyn::detail::right_mult_expression().

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 53 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::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::detail::polynomialset_impl< Context, Kind >::hash(), vcsn::detail::polynomialset_impl< Context, Kind >::infiltration(), vcsn::detail::polynomialset_impl< Context, Kind >::ldiv(), vcsn::detail::polynomialset_impl< Context, Kind >::lmul(), vcsn::detail::polynomialset_impl< Context, Kind >::lmul_label(), 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::polynomialset_impl< Context, Kind >::print_with_classes_(), vcsn::rat::split_visitor< ExpSet >::product(), vcsn::detail::polynomialset_impl< Context, Kind >::project(), vcsn::rat::expansionset< expressionset_t >::rmul(), vcsn::detail::polynomialset_impl< Context, Kind >::rmul(), vcsn::detail::polynomialset_impl< Context, Kind >::rmul_label(), 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::expand_visitor< ExpSet >::VCSN_RAT_VISIT(), 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::universaler< 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 
)

Definition at line 16 of file ladybird.hh.

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

Referenced by vcsn::dyn::ladybird(), 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::ldiv ( const ValueSet &  vs,
const typename ValueSet::value_t &  lhs,
const typename ValueSet::value_t &  rhs 
)
inline

Left-division of values.

Definition at line 17 of file divide.hh.

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

Compute the left quotient.

Parameters
a1left hand side
a2right hand side

Definition at line 582 of file conjunction.hh.

References copy(), and vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::ldiv_here().

Referenced by info().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
Aut2& vcsn::ldiv_here ( const Aut1 &  lhs,
Aut2 &  res 
)

Compute the left quotient in place.

Parameters
lhsleft hand side
resright hand side, which holds the result

Definition at line 564 of file conjunction.hh.

References vcsn::detail::join_automata().

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

Here is the call graph for this function:

template<Automaton Aut, typename Tag = auto_tag>
auto vcsn::left_mult ( 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 128 of file left-mult.hh.

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

template<typename ValueSet >
auto vcsn::left_mult ( const ValueSet &  rs,
const weight_t_of< ValueSet > &  w,
const typename ValueSet::value_t &  r 
) -> decltype(rs.lmul(w, r))

Definition at line 188 of file left-mult.hh.

References vcsn::detail::rs.

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

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

Definition at line 120 of file left-mult.hh.

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

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 135 of file letterize.hh.

References vcsn::detail::letterize().

Referenced by vcsn::dyn::letterize(), and 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 17 of file levenshtein.hh.

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

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

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

Left-division of values.

Definition at line 61 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 = {} 
)
inline

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 vcsn::dyn::detail::lift_expression(), and to_expression_heuristic().

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

Move all the labels to the weights.

Definition at line 294 of file lift.hh.

References vcsn::detail::lift_expressionset().

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.

Definition at line 191 of file lightest.hh.

References lightest_path(), and path_monomial().

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,
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.

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

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 16 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 23 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 47 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 75 of file bellman-ford.hh.

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

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 ambiguous_word(), lightest(), and vcsn::detail::lightest_path_tag().

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

Definition at line 240 of file print.hh.

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

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 386 of file compose.hh.

References insplit_lazy().

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)

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

References is, and str_escape().

Referenced by has_twins_property(), join_weightset_expressionset(), 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.

Definition at line 249 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 189 of file delay-automaton.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 311 of file derived-term.hh.

References vcsn::detail::rs.

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

template<typename ExpSet >
expansionset<ExpSet> vcsn::make_expansionset ( const ExpSet &  expset)

Definition at line 670 of file expansionset.hh.

Referenced by join_weightset_expansionset().

template<typename Context >
expressionset<Context> vcsn::make_expressionset ( const Context &  ctx,
rat::identities  identities = {} 
)
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 90 of file copy.hh.

References vcsn::detail::real_context().

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

Here is the call graph for this function:

template<Automaton Aut>
auto vcsn::make_insplit_automaton ( const Aut &  aut) -> insplit_automaton<Aut>

Definition at line 316 of file insplit.hh.

Referenced by vcsn::detail::insplit(), and insplit_lazy().

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

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

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

Referenced by 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.

template<bool Lazy, Automaton Aut, Automaton... Auts>
auto vcsn::make_product_automaton ( Aut  aut,
const Auts &...  auts 
) -> product_automaton<Lazy, Aut, Auts...>
inline

Definition at line 467 of file conjunction.hh.

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

Definition at line 56 of file random.hh.

Referenced by random_label().

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

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

Definition at line 14 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 354 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 388 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>>
inline

The meet of two expressionsets.

Definition at line 564 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 660 of file nullableset.hh.

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

Definition at line 663 of file nullableset.hh.

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

Definition at line 666 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 670 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 27 of file minimize-hopcroft.hh.

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

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(), detail::make_join_automaton(tag, lhs, rhs))
template<Automaton Aut, typename Tag = general_tag>
auto vcsn::multiply ( const Aut &  aut,
int  min,
int  max,
Tag  tag = {} 
) -> decltype(aut->null_state(), detail::make_join_automaton(tag, aut))

Repeated concatenation of an automaton.

The return type, via SFINAE on aut->null_state(), makes the difference with another overload, <ValueSet>(ValueSet, value, value), which coincides in the case ValueSet = Z, hence value = int.

Unfortunately, fresh_automaton_t_of, which uses context_t_of<Aut>, is not SFINAE transparent: it causes a hard failure instead of being ignored.

FIXME: if you know how to use fresh_automaton_t_of instead, let me know.

Definition at line 203 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 281 of file multiply.hh.

template<typename ExpSet >
ExpSet::value_t vcsn::multiply ( const ExpSet &  rs,
const typename ExpSet::value_t &  r,
int  min,
int  max 
)

Definition at line 330 of file multiply.hh.

References require(), and sum().

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

Here is the call graph for this function:

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

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(), and vcsn::detail::make_vector().

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 >::ldiv_here(), and vcsn::dyn::normalize().

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

Number of non-deterministic states of transpositive 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)
inline

Number of non-deterministic states.

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

References is_deterministic().

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 137 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(), 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 81 of file stream.cc.

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 96 of file stream.cc.

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 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(), forward, and is.

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.

References is.

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 38 of file partial-identity.hh.

References vcsn::detail::all_transitions(), and vcsn::detail::back().

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

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 stc to dst.

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

References vcsn::detail::make_word_polynomialset().

Referenced by ambiguous_word(), lightest(), and vcsn::detail::enumerater< Aut >::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 73 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(), and prefix_here().

Referenced by vcsn::ast::context_parser::automaton_(), vcsn::detail::synchronizer< Aut >::get_prefix(), and vcsn::dyn::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,
const std::string &  fmt 
)
template<typename ValueSet >
std::ostream& vcsn::print ( const ValueSet &  vs,
const typename ValueSet::value_t &  v,
std::ostream &  o,
format  fmt 
)

Print a value thanks to a valueset.

Applies to (ValueSet, Value, ostream, string): for expansionset, polynomialset, expressionset, and weightset.

Definition at line 148 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,
format  fmt 
)

Print an expression.

Definition at line 177 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,
const std::string &  fmt 
)

Print an expression.

Definition at line 187 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(), and make_mutable_automaton().

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 236 of file proper.hh.

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

Referenced by vcsn::dyn::proper(), 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" 
)
inline

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

Definition at line 270 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 253 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(), and shortest_distance_to_finals().

Referenced by vcsn::dyn::push_weights(), and 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>
inline

Definition at line 124 of file quotient.hh.

Referenced by minimize().

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

Raise a runtime_error with the concatenation of args as message.

Definition at line 62 of file raise.hh.

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

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,
float  loop_chance = 0.0 
)

Definition at line 118 of file random.hh.

References vcsn::rat::ctx(), random_label(), and require().

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

Here is the call graph for this function:

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

Definition at line 279 of file random.hh.

References vcsn::rat::ctx(), and require().

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

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 20 of file random.hh.

References vcsn::oneset::one().

Referenced by random_automaton(), random_label(), and random_label_().

Here is the call graph for this function:

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 31 of file random.hh.

References random_label_().

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 57 of file random.hh.

References vcsn::detail::genset_labelset< GenSet >::generators(), make_random_selector(), vcsn::detail::genset_labelset< GenSet >::mul(), vcsn::wordset< GenSet >::one(), require(), and vcsn::wordset< GenSet >::value().

Here is the call graph for this function:

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 75 of file random.hh.

References make_random_selector(), and require().

Here is the call graph for this function:

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 90 of file random.hh.

References vcsn::nullableset< LabelSet >::generators(), vcsn::nullableset< LabelSet >::labelset(), vcsn::nullableset< LabelSet >::one(), random_label(), and vcsn::nullableset< LabelSet >::value().

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 106 of file random.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 43 of file random.hh.

References random_label().

Referenced by random_label().

Here is the call graph for this function:

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

Right-division of values.

Definition at line 94 of file divide.hh.

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

Compute the right quotient.

Parameters
a1left hand side
a2right hand side

Definition at line 616 of file conjunction.hh.

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

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

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>
inline

Definition at line 20 of file read.hh.

References vcsn::rat::ctx(), and is.

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

Here is the call graph for this function:

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

Definition at line 51 of file read.hh.

References conv(), vcsn::rat::ctx(), and is.

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>
inline

Definition at line 82 of file read.hh.

References vcsn::rat::ctx(), and is.

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

Here is the call graph for this function:

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 220 of file letterize.hh.

References letterize(), and proper().

Referenced by are_equivalent(), and vcsn::dyn::realtime().

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

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 78 of file raise.hh.

Referenced by vcsn::edit_automaton< Aut >::add_entry(), vcsn::set_alphabet< L >::add_letter(), ambiguous_word(), cerny(), complement_here(), conjugate(), 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(), eval(), 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 >::infiltration(), vcsn::detail::word_synchronizer< Aut >::init_synchro(), is_synchronized_by(), ladybird(), vcsn::detail::standard_operations< Aut >::left_mult_here(), vcsn::rat::expressionset_impl< Context >::letter_class_(), vcsn::detail::z_impl::lgcd(), vcsn::detail::r_impl::lgcd(), vcsn::detail::b_impl::lgcd(), vcsn::detail::q_impl::lgcd(), lightest_path(), 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(), multiply(), 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_(), random_automaton(), random_automaton_deterministic(), random_label(), vcsn::detail::min_plus_impl< unsigned int >::rdiv(), vcsn::detail::log_impl::rdiv(), vcsn::detail::f2_impl::rdiv(), vcsn::detail::qmp_impl::rdiv(), vcsn::detail::z_impl::rdiv(), vcsn::detail::b_impl::rdiv(), vcsn::detail::r_impl::rdiv(), vcsn::detail::q_impl::rdiv(), vcsn::dyn::read_efsm(), vcsn::detail::f2_impl::star(), star_here(), sum_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::right_mult ( const Aut &  aut,
const weight_t_of< Aut > &  w,
Tag  tag = {} 
)

Right-multiplication of an automaton by a weight.

Definition at line 301 of file left-mult.hh.

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

template<typename ValueSet >
ValueSet::value_t vcsn::right_mult ( const ValueSet &  rs,
const typename ValueSet::value_t &  r,
const weight_t_of< ValueSet > &  w 
)

Definition at line 360 of file left-mult.hh.

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

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

Definition at line 293 of file left-mult.hh.

Referenced by vcsn::dyn::detail::right_mult_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 174 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 &  s1,
const Container &  s2 
)

The set of members of s1 that are not members of s2.

Definition at line 150 of file algorithm.hh.

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

template<typename Key , typename Hash , typename KeyEqual , typename Alloc >
std::unordered_set<Key, Hash, KeyEqual, Alloc> vcsn::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.

Definition at line 45 of file unordered_set.hh.

References has(), and set_intersection().

Here is the call graph for this function:

template<typename Container , typename = typename Container::value_type>
Container vcsn::set_intersection ( const Container &  s1,
const Container &  s2 
)

The intersection of two sets.

Definition at line 163 of file algorithm.hh.

Referenced by intersection_closure(), set_intersection(), and useful_states().

template<typename Container , typename = typename Container::value_type>
Container vcsn::set_union ( const Container &  s1,
const Container &  s2 
)

The union of two sets.

Definition at line 196 of file algorithm.hh.

template<Automaton Aut>
detail::enumerater<Aut>::polynomial_t vcsn::shortest ( const Aut &  aut,
boost::optional< unsigned >  num = {},
boost::optional< unsigned >  len = {} 
)

The approximated behavior of an automaton.

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

Definition at line 267 of file shortest.hh.

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

template<Automaton Aut>
weight_t_of<Aut> vcsn::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.

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

References ss_shortest_distance().

Referenced by push_weights(), and shortest_distance_to_finals().

Here is the call graph for this function:

template<Automaton Aut>
std::unordered_map<state_t_of<Aut>, weight_t_of<Aut> > vcsn::shortest_distance_to_finals ( Aut  aut)

Find all shortest distances of each state to the final states of aut.

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

References shortest_distance_to_finals().

Here is the call graph for this function:

template<Automaton... Auts>
auto vcsn::shuffle ( const Auts &...  as) -> tuple_automaton<decltype(join_automata(as...)), Auts...>

The (accessible part of the) shuffle product.

Definition at line 648 of file conjunction.hh.

References vcsn::detail::join_automata().

Referenced by info(), vcsn::dyn::detail::shuffle_(), and vcsn::dyn::detail::shuffle_expression().

Here is the call graph for this function:

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

Shuffle product of expressions.

Definition at line 691 of file conjunction.hh.

template<typename T >
symbol vcsn::sname ( )

Definition at line 67 of file name.hh.

References vcsn::snamer< T >::name().

Referenced by vcsn::detail::label_one(), vcsn::dyn::make_context(), vcsn::detail::expression_automaton_impl< Aut >::sname(), vcsn::set_alphabet< L >::sname(), vcsn::detail::genset_labelset< GenSet >::sname(), vcsn::detail::permutation_automaton_impl< Aut >::sname(), vcsn::detail::name_automaton_impl< Aut >::sname(), vcsn::detail::lazy_proper_automaton_impl< Aut, has_one >::sname(), vcsn::detail::insplit_automaton_impl< Aut, HasOne >::sname(), vcsn::detail::filter_automaton_impl< Aut >::sname(), vcsn::detail::transpose_automaton_impl< Aut >::sname(), vcsn::rat::expansionset< expressionset_t >::sname(), vcsn::detail::partition_automaton_impl< Aut >::sname(), vcsn::context< Tape, full_context_t >::sname(), vcsn::detail::delay_automaton_impl< Aut >::sname(), vcsn::detail::determinized_automaton_impl< Aut, Kind, Lazy >::sname(), vcsn::rat::expressionset_impl< Context >::sname(), vcsn::detail::synchronized_automaton_impl< Aut >::sname(), vcsn::detail::polynomialset_impl< Context, Kind >::sname(), vcsn::detail::focus_automaton_impl< Tape, Aut >::sname(), vcsn::detail::pair_automaton_impl< Aut >::sname(), vcsn::detail::mutable_automaton_impl< Context >::sname(), vcsn::detail::compose_automaton_impl< Lazy, Lhs, Rhs >::sname(), vcsn::detail::derived_term_automaton_impl< ExpSet >::sname(), vcsn::nullableset< LabelSet >::sname(), vcsn::detail::insplit_automaton_impl< Aut, false >::sname(), vcsn::detail::scc_automaton_impl< Aut >::sname(), vcsn::detail::tuple_automaton_impl< Aut, Auts >::sname_(), and vcsn::detail::tupleset_impl< ValueSets >::sname_().

Here is the call graph for this function:

template<typename T >
symbol vcsn::sname ( T &  )

Definition at line 73 of file name.hh.

Referenced by vcsn::snamer< T >::name().

template<typename ExpSet >
rat::expression_polynomial_t<ExpSet> vcsn::split ( const ExpSet &  rs,
const typename ExpSet::value_t &  e 
)
inline
template<typename ExpSet >
rat::expression_polynomial_t<ExpSet> vcsn::split ( const ExpSet &  rs,
const rat::expression_polynomial_t< ExpSet > &  p 
)
inline

Split a polynomial of expressions, given the expressionset.

Definition at line 308 of file split.hh.

References vcsn::rat::make_expression_polynomialset(), and split_polynomial().

Here is the call graph for this function:

template<typename PolynomialSet >
PolynomialSet::value_t vcsn::split_polynomial ( const PolynomialSet &  ps,
const typename PolynomialSet::value_t &  p 
)
inline

Split a polynomial of expressions, given the polynomialset.

Definition at line 292 of file split.hh.

References label_of(), vcsn::detail::rs, split(), and weight_of().

Referenced by split().

Here is the call graph for this function:

template<Automaton Aut>
std::vector<weight_t_of<Aut> > vcsn::ss_shortest_distance ( const Aut &  aut,
state_t_of< Aut >  s0 
)

Single source shortest distance.

Find shortest (weighted) path from state s0 to all states of automaton aut.

Definition at line 29 of file distance.hh.

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

Referenced by shortest_distance_to_finals().

Here is the call graph for this function:

template<typename... Args>
signature vcsn::ssignature ( )
inline

Static signature.

Definition at line 82 of file name.hh.

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

Definition at line 115 of file standard.hh.

References copy(), and standard_here().

Referenced by costandard(), normalize(), vcsn::ctx::detail::register_functions(), standard(), and vcsn::dyn::standard().

Here is the call graph for this function:

template<Automaton Aut, typename ExpSet >
Aut vcsn::standard ( const ExpSet &  rs,
const typename ExpSet::value_t &  r 
)

Build a standard automaton from an expression.

Template Parameters
Autrelative to the generated automaton.
ExpSetrelative to the expression.

Definition at line 375 of file standard.hh.

References standard().

Here is the call graph for this function:

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

Turn aut into a standard automaton.

Template Parameters
Autan automaton type, not a pointer type.

Definition at line 80 of file standard.hh.

References vcsn::detail::all_in(), vcsn::detail::all_out(), vcsn::detail::initial_transitions(), and is_standard().

Referenced by standard(), and star_here().

Here is the call graph for this function:

template<Automaton Aut, typename Tag = general_tag>
auto vcsn::star ( const Aut &  aut,
Tag  tag = {} 
) -> decltype(detail::make_join_automaton(tag, aut))

Star of an automaton.

Definition at line 108 of file star.hh.

Referenced by info(), and vcsn::dyn::star().

template<typename ExpSet >
unsigned vcsn::star_height ( const typename ExpSet::value_t &  e)
inline

Star height of an expression.

Definition at line 100 of file star-height.hh.

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

template<Automaton Aut>
Aut& vcsn::star_here ( Aut &  res,
general_tag  = {} 
)

In-place star of an automaton.

Definition at line 23 of file star.hh.

Referenced by star_here().

template<Automaton Aut>
Aut& vcsn::star_here ( Aut &  res,
standard_tag   
)

In-place star of a standard automaton.

See standard_visitor::visit(star).

Standard algorithm requires standard automaton because there is a problem with "final weight of the initial state" if the automaton has several initial states. Indeed we cannot preserve several initial states since (a+b) is not equal to (a*+b*)

Definition at line 51 of file star.hh.

References vcsn::detail::final_transitions(), vcsn::detail::front(), vcsn::detail::initial_transitions(), is_standard(), vcsn::detail::out(), and require().

Here is the call graph for this function:

template<Automaton Aut>
Aut& vcsn::star_here ( Aut &  res,
deterministic_tag   
)

In-place star of a deterministic automaton.

Definition at line 94 of file star.hh.

References determinize(), standard_here(), and star_here().

Here is the call graph for this function:

template<typename ExpSet >
ExpSet::value_t vcsn::star_normal_form ( const ExpSet &  rs,
const typename ExpSet::value_t &  e 
)
inline

Star-normal form of an expression.

Definition at line 185 of file star-normal-form.hh.

std::string vcsn::str_escape ( const std::string &  c,
const char special = nullptr 
)

Likewise, but produces a string.

Definition at line 62 of file escape.cc.

References str_escape().

Here is the call graph for this function:

template<typename T >
std::string vcsn::str_escape ( const std::vector< T > &  s,
const char special = nullptr 
)

A container of letters.

Definition at line 22 of file escape.hh.

References str_escape().

Here is the call graph for this function:

std::ostream & vcsn::str_escape ( std::ostream &  os,
int  c,
const char special = nullptr 
)

Output a character, escaping special characters.

-1 denotes end-of-file.

Definition at line 13 of file escape.cc.

References os.

std::string vcsn::str_escape ( int  c,
const char special = nullptr 
)

Likewise, but produces a string.

Definition at line 46 of file escape.cc.

References str_escape().

Here is the call graph for this function:

Definition at line 277 of file string.hh.

References vcsn::string_letters::special_letter().

Here is the call graph for this function:

Definition at line 285 of file string.hh.

References vcsn::string_letters::special_letter().

Here is the call graph for this function:

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

Remove (all) the decorations from a decorated automaton.

Definition at line 34 of file strip.hh.

References vcsn::detail::strip().

Referenced by are_equivalent(), difference(), and vcsn::dyn::strip().

Here is the call graph for this function:

template<Automaton Aut, typename Tag = auto_tag>
const detail::components_t<Aut> vcsn::strong_components ( const Aut &  aut,
Tag  = {} 
)

Find all strongly connected components of aut.

Template Parameters
Autthe automaton type.
Tagspecifies the chosen algorithm.

Definition at line 540 of file scc.hh.

Referenced by has_twins_property(), is_cycle_ambiguous(), is_cycle_ambiguous_scc(), vcsn::detail::scc_automaton_impl< Aut >::scc_automaton_impl(), and strong_components().

template<Automaton Aut>
const detail::components_t<Aut> vcsn::strong_components ( const Aut &  aut,
scc_algo_t  algo = scc_algo_t::tarjan_iterative 
)

Find all strongly connected components of aut.

Parameters
autthe input automaton.
algospecifies the chosen algorithm.

Definition at line 551 of file scc.hh.

References auto_, BUILTIN_UNREACHABLE, dijkstra, kosaraju, strong_components(), tarjan_iterative, and tarjan_recursive.

Here is the call graph for this function:

template<typename Container >
bool vcsn::subset ( const Container &  set1,
const Container &  set2 
)

Whether set1set2.

Definition at line 48 of file set.hxx.

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

template<Automaton Aut>
auto vcsn::subword ( const Aut &  aut) -> decltype(make_nullable_automaton(aut->context()))

Apply subword_here() to a copy of aut.

Definition at line 158 of file prefix.hh.

References copy_into(), make_nullable_automaton(), and subword_here().

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

Here is the call graph for this function:

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

Add spontaneous transitions for each non spontaneous transition, with same source, destination and weight.

Definition at line 137 of file prefix.hh.

References vcsn::detail::out().

Referenced by subword().

Here is the call graph for this function:

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

Definition at line 29 of file prefix.hh.

References copy(), and suffix_here().

Referenced by vcsn::detail::synchronizer< Aut >::get_prefix(), and vcsn::dyn::suffix().

Here is the call graph for this function:

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

Make all accessible states initial.

Definition at line 17 of file prefix.hh.

References accessible_states().

Referenced by factor_here(), prefix_here(), and suffix().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2, typename Tag = general_tag>
auto vcsn::sum ( 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 95 of file sum.hh.

Referenced by info(), multiply(), vcsn::are_isomorphicer< Aut1, Aut2 >::print_class_stats(), vcsn::dyn::sum(), vcsn::dyn::detail::sum_expansion(), and vcsn::dyn::detail::sum_expression().

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

Sums of values.

Definition at line 133 of file sum.hh.

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::sum_here ( Aut1 &  res,
const Aut2 &  b,
deterministic_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 30 of file sum.hh.

References determinize().

Here is the call graph for this function:

template<Automaton Aut1, Automaton Aut2>
Aut1& vcsn::sum_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 45 of file sum.hh.

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

Here is the call graph for this function:

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

Merge transitions of b into those of res.

Precondition
Aut2 <: Aut1.

Definition at line 82 of file sum.hh.

References copy_into().

Here is the call graph for this function:

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

Synchronize the transducer.

Parameters
[in]autthe transducer
Returns
the synchronized transducer

Definition at line 350 of file synchronize.hh.

References vcsn::dyn::detail::synchronize().

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

Here is the call graph for this function:

template<Automaton Aut>
word_t_of<Aut> vcsn::synchronizing_word ( const Aut &  aut,
const std::string &  algo = "greedy" 
)

Return a synchronizing word for aut using algo algo.

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

References vcsn::detail::word_synchronizer< Aut >::cycle(), vcsn::detail::word_synchronizer< Aut >::fastsynchro(), vcsn::detail::word_synchronizer< Aut >::greedy(), str_escape(), vcsn::detail::word_synchronizer< Aut >::synchroP(), and vcsn::detail::word_synchronizer< Aut >::synchroPL().

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

Here is the call graph for this function:

template<Automaton Aut, typename ExpSet >
Aut vcsn::thompson ( const context_t_of< Aut > &  ctx,
const ExpSet &  rs,
const typename ExpSet::value_t &  r 
)
inline

Build a Thompson automaton from an expression.

Template Parameters
Autrelative to the generated automaton.
ExpSetrelative to the expression.

Definition at line 176 of file thompson.hh.

References vcsn::rat::ctx().

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

Here is the call graph for this function:

template<Automaton Aut, typename ExpSet >
Aut vcsn::thompson ( const ExpSet &  rs,
const typename ExpSet::valu