Namespaces
	dot
	Implementation details of the dot parser.

Classes
struct	a_star_impl
	A Star implementation of lightest automaton. More...

struct	and_
	And condition on several typenames. More...

struct	and_< F1 >

struct	and_< F1, F... >

struct	and_<>

class	automaton_decorator
	Aggregate an automaton, and forward calls to it. More...

class	b_impl

class	backslashify_output_filter
	Backslash backslashes. More...

class	bounded_lag_checker

class	compose_automaton_impl
	Build the (accessible part of the) composition. More...

struct	composed_type
	Build the (accessible part of the) composition. More...

struct	concat

struct	concat< index_sequence< I1... >, index_sequence< I2... > >

struct	concat_index_sequence

struct	concat_index_sequence< index_sequence< I1... >, index_sequence< I2... > >

struct	concat_tupleset

struct	concat_tupleset< weightset_mixin< tupleset_impl< T1... > >, weightset_mixin< tupleset_impl< T2... > > >

struct	context_t_of_impl

struct	context_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::context_t > >

struct	context_t_of_impl< ValueSet *, void_t< typename ValueSet::context_t > >

struct	context_t_of_impl< ValueSet, void_t< typename ValueSet::context_t > >

class	copier
	Copy an automaton. More...

class	cycle_identity_impl
	Whether all the paths between any two states have the same weight (i.e., for all s0, s1, any two paths p0, p1 between s0 and s1 have the same weight w_{s0,s1}). More...

class	daut_impl
	Format an automaton into Daut. More...

class	delay_automaton_impl
	An automaton whose states may be qualified by delays and/or prefixes. More...

struct	delgado_profiler
	Compute a state profile for state-elimination based on the Delgado-Morais heuristic. More...

struct	derived_term_algo
	Specify a variety of derived-term construction. More...

class	derived_term_automaton_impl
	Compute the derived-term automaton from an expression. More...

struct	derived_term_automaton_members
	Additional members when the labelset is letterized. More...

struct	derived_term_automaton_members< ExpSet, false >
	Additional members when the labelset is not letterized. More...

struct	detect

struct	detect< T, Op, void_t< Op< T > > >

class	determinized_automaton_impl
	The subset construction automaton from another. More...

struct	dijkstra_impl
	Dijkstra implementation of lightest automaton. More...

class	dot_impl
	Format an automaton into Dot. More...

struct	down_caster
	A functor that captures the current location (to report errors), and provides "cast". More...

class	efsmer
	Print automaton to EFSM format, based on FSM format. More...

class	enumerater
	Compute the shortest words accepted by an automaton. More...

struct	epsilon_profile
	This is used by some epsilon removal algorithms. More...

class	epsilon_remover
	This class contains the core of the proper algorithm. More...

class	epsilon_remover< Aut, false >

class	epsilon_remover_distance
	This class contains the core of the proper algorithm. More...

class	epsilon_remover_distance< Aut, false >

class	epsilon_remover_separate
	This class contains the core of the proper algorithm. More...

class	epsilon_remover_separate< Aut, false >

struct	eval_if

struct	eval_if_c
	Test if (c) then F1 else F2 and get the value. More...

class	evaluator
	Evaluate a word on an automaton. More...

class	expression_automaton_impl
	An incremental automaton whose states are expressions. More...

class	f2_impl

class	fado_impl
	Format an automaton into FAdo. More...

class	filter_automaton_impl
	Hide some states of an automaton. More...

class	focus_automaton_impl
	Read-write on an automaton, that hides all tapes but one. More...

struct	full_context_t_of_impl

struct	full_context_t_of_impl< insplit_automaton< Aut > >

struct	genset_labelset
	This class has no modeling purpose, it only serves to factor code common to letterset and wordset. More...

class	grail_impl
	Print an automaton in Fado format. More...

struct	hidden_label_type

struct	hidden_label_type< Aut, index_sequence< I... > >

struct	if_

struct	if_c

struct	if_c< false, T1, T2 >

struct	index_sequence

struct	index_sequence_difference
	Get the list containing all the elements of I1 (contiguous sequence from 0 to N) not present in I2 (arbitrary sequence, sorted). More...

struct	index_sequence_difference< index_sequence< I1_1, I1... >, index_sequence< I1_1, I2... > >

struct	index_sequence_difference< index_sequence< I1_1, I1... >, index_sequence< I2_1, I2... > >

struct	index_sequence_difference< index_sequence< I1_1, I1... >, index_sequence<> >

struct	index_sequence_difference< index_sequence<>, index_sequence<> >

struct	index_t_impl
	Lightweight state/transition handle (or index). More...

class	insplit_automaton_impl
	Insplit automaton decorator. More...

struct	int_range

struct	int_range< off, index_sequence< I... > >

class	is_acyclic_impl
	Detect circuits. More...

struct	is_ambiguous_impl
	Whether an automaton is ambiguous. More...

struct	is_division_ring

struct	is_division_ring< polynomialset< Context, Kind > >

struct	is_division_ring< z >

struct	is_multitape
	Whether a ValueSet, or a context, is multitape. More...

struct	is_multitape< context< LabelSet, WeightSet > >

struct	is_multitape< expressionset< Context > >

struct	is_multitape< tupleset< ValueSet... > >

struct	is_special_t
	Needed for GCC 5 and 6 that refuse deduced return type for transitions() when using a lambda. More...

class	is_valid_impl

class	is_valid_impl< Aut, false >

struct	join_impl
	A structure that implements the computation of join(V1, V2). More...

struct	join_impl< b, expressionset< Context > >

struct	join_impl< context< LS1, WS1 >, context< LS2, WS2 > >
	The join of two contexts. More...

struct	join_impl< expansionset< expressionset< Ctx1 > >, expansionset< expressionset< Ctx2 > > >
	The join of two expansionsets. More...

struct	join_impl< expressionset< Ctx1 >, expressionset< Ctx2 > >
	The join of two expressionsets. More...

struct	join_impl< letterset< GenSet >, letterset< GenSet > >

struct	join_impl< letterset< GenSet >, wordset< GenSet > >
	The join with another labelset. More...

struct	join_impl< letterset< GenSet1 >, expressionset< Ctx2 > >
	Join of a letterset and an expressionset. More...

struct	join_impl< nullableset< letterset< GenSet > >, wordset< GenSet > >

struct	join_impl< nullableset< LS1 >, LS2 >
	The join with another labelset. More...

struct	join_impl< nullableset< LS1 >, nullableset< LS2 > >
	The join with another labelset. More...

struct	join_impl< oneset, oneset >

struct	join_impl< polynomialset< Ctx1, Kind1 >, polynomialset< Ctx2, Kind2 > >

struct	join_impl< polynomialset< Ctx1, Kind1 >, WS2 >

struct	join_impl< q, expressionset< Context > >

struct	join_impl< r, expressionset< Context > >

struct	join_impl< rat::identities, rat::identities >

struct	join_impl< tupleset< VS1... >, tupleset< VS2... > >
	Join between two tuplesets, of the same size. More...

struct	join_impl< tupleset< VS1... >, VS2 >
	Join between a tupleset, and a non tuple. More...

struct	join_impl< wordset< GenSet >, wordset< GenSet > >

struct	join_impl< z, expressionset< Context > >

struct	join_impl< zmin, expressionset< Context > >

struct	join_impl_simple

struct	join_impl_simple< WeightSet, expressionset< Context > >

struct	label_t_of_impl

struct	label_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::label_t > >

struct	label_t_of_impl< ValueSet *, void_t< typename ValueSet::label_t > >

struct	label_t_of_impl< ValueSet, void_t< typename ValueSet::label_t > >

struct	labelset_t_of_impl

struct	labelset_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::labelset_t > >

struct	labelset_t_of_impl< ValueSet *, void_t< typename ValueSet::labelset_t > >

struct	labelset_t_of_impl< ValueSet, void_t< typename ValueSet::labelset_t > >

struct	labelset_types_impl
	A traits so that tupleset may define types that may exist. More...

struct	labelset_types_impl< decltype(pass{std::declval< ValueSets >().genset()...}, void()), ValueSets... >
	Specialization for tuples of labelsets. More...

struct	law_traits
	The LAW from a LAL. More...

struct	law_traits< expressionset< Ctx > >
	Conversion to a wordset: identity. More...

struct	law_traits< letterset< GenSet > >
	Conversion for letterset<GenSet> to a super wordset. More...

struct	law_traits< nullableset< LabelSet > >
	Conversion for nullable<LabelSet> to a super wordset. More...

struct	law_traits< oneset >
	Conversion to a wordset: identity. More...

struct	law_traits< tupleset< LabelSets... > >
	Conversion to wordset. More...

struct	law_traits< wordset< GenSet > >

class	lazy_proper_automaton_impl
	Build a "lazy proper" automaton from the input with nullable labels. More...

class	lazy_proper_automaton_impl< Aut, false >
	Specialization for automata with non nullable context. More...

class	lazy_tuple_automaton
	Decorator implementing the laziness for an algorithm. More...

class	left_reductioner

struct	letterized_traits
	A traits to compute the letterized context. More...

struct	letterized_traits< letterset< GenSet > >
	Conversion to letterized. More...

struct	letterized_traits< nullableset< LabelSet > >
	Conversion to letterized. More...

struct	letterized_traits< tupleset< LabelSets... > >
	Conversion to letterized. More...

struct	letterized_traits< wordset< GenSet > >
	Conversion to letterized. More...

class	letterizer
	From an automaton, the corresponding automaton with a non-word labelset. More...

struct	lifter_impl
	Helper structure for a lift of several tapes. More...

struct	lifter_impl< Context, vcsn::detail::index_sequence<> >
	Lift all the label tapes to the weights. More...

class	lightest_impl
	The lightest algorithm computes the paths between pre and post with the smallest weight possible. More...

class	log_impl

struct	make_index_range
	A static range. More...

struct	make_index_range_impl
	A static range. More...

struct	make_index_range_impl< S, 0 >

struct	make_index_range_impl< S,-1U >

struct	make_index_sequence

struct	make_index_sequence< 0 >

struct	make_index_sequence< 1 >

class	min_plus_impl

class	minimizer

class	minimizer< Aut, moore_tag >

class	minimizer< Aut, signature_tag >

class	minimizer< Aut, weighted_tag >

class	mutable_automaton_impl
	Bidirectional automata. More...

struct	naive_profiler
	Compute a state profile for state-elimination based on connectivity. More...

class	name_automaton_impl
	An incremental automaton whose states are names. More...

class	nmin_impl

struct	nullable_helper
	Add support for an empty word to a LabelSet that does not provide such special label to this end. More...

struct	nullable_helper< letterset< GenSet > >
	Add support for an empty word to a letterset thanks to the one() of its genset. More...

struct	nullableset_traits
	The smallest nullableset which includes LabelSet. More...

struct	nullableset_traits< expressionset< Ctx > >
	Conversion to a nullableset: identity. More...

struct	nullableset_traits< letterset< GenSet > >
	Conversion for letterset<GenSet> to a nullableset. More...

struct	nullableset_traits< nullableset< LabelSet > >
	Conversion for nullable<LabelSet> to a nullableset: id. More...

struct	nullableset_traits< oneset >
	Conversion to a nullableset: identity. More...

struct	nullableset_traits< wordset< GenSet > >
	wordset is already a nullableset. More...

class	optional_container
	Enables or not the presence of a container in a class. More...

class	optional_container< Container, true >

struct	or_
	Or condition on several typenames. More...

struct	or_< F1 >

struct	or_< F1, F... >

struct	or_<>

struct	origins_t_of_impl
	From an (input) automaton type, compute its origin_t type. More...

struct	origins_t_of_impl< partition_automaton< Aut > >

struct	origins_t_of_impl< transpose_automaton< Aut > >

class	pair_automaton_impl
	The pair automaton is used by several algorithms for synchronizing words. More...

struct	partial_identity_context

class	partition_automaton_impl
	An automaton wrapper whose states form a partition of the state set of another automaton. More...

struct	partition_automaton_t_impl
	From an (input) automaton type, compute the right decorator for its partition_automaton. More...

struct	partition_automaton_t_impl< partition_automaton< Aut > >

struct	partition_automaton_t_impl< transpose_automaton< Aut > >

struct	pass
	Ignore its arguments. More...

class	permutation_automaton_impl
	An automaton isomorphic to another one. More...

class	polynomialset_impl
	Linear combination of labels: map labels to weights. More...

class	polystate_automaton_impl
	An automaton whose state names are polynomials of states. More...

class	printer
	Factor common bits in automaton formatting. More...

class	product_automaton_impl
	Build the (accessible part of the) product. More...

struct	project_labelset_impl
	The type of the resulting apparent LabelSet when keeping only tape Tape. More...

struct	project_labelset_impl< Tape, expressionset< Context > >
	Case of multitape expressionsets. More...

struct	project_labelset_impl< Tape, tupleset< LabelSets... > >
	Case of tuplesets. More...

struct	proper_traits
	From a labelset, its non-nullable labelset. More...

struct	proper_traits< nullableset< LabelSet > >

struct	proper_traits< tupleset< LabelSet > >
	Transform a tupleset of one element to a tupleset of the proper version. More...

class	properer
	Spontaneous transition elimination. More...

class	q_impl

class	qmp_impl

class	quotienter
	Apply a quotient onto an automaton: fuse equivalent states. More...

class	r_impl

class	random_expression_impl
	Class random expression generator. More...

class	random_weight
	Generic declaration of the class which is specialized in each weightset. More...

class	random_weight< b, RandomGenerator >
	Random generation. More...

class	random_weight< f2, RandomGenerator >
	Random generation. More...

class	random_weight< log, RandomGenerator >

class	random_weight< nmin, RandomGenerator >

class	random_weight< q, RandomGenerator >
	Random generation. More...

class	random_weight< qmp, RandomGenerator >
	Random generation. More...

class	random_weight< r, RandomGenerator >

class	random_weight< rmin, RandomGenerator >

class	random_weight< z, RandomGenerator >
	Random generation. More...

class	random_weight< zmin, RandomGenerator >

class	random_weight_base
	Abstract class for random weight generation. More...

struct	rank
	Number of tapes. More...

struct	rank< tupleset< LabelSet... > >

struct	real_context_impl
	When we copy a focus automaton, we create another focus automaton. More...

struct	real_context_impl< automaton_decorator< Aut > >
	Be recursive on automaton wrappers. More...

struct	real_context_impl< focus_automaton< Tape, Aut > >

struct	res_label_t_of_impl

struct	res_label_t_of_impl< insplit_automaton< Aut > >

struct	res_labelset_t_of_impl

struct	res_labelset_t_of_impl< insplit_automaton< Aut > >

class	reverse_postorder_impl
	Get all states in reverse postorder using depth first search. More...

class	rmin_impl

struct	safe_filtered

class	scc_automaton_impl
	An automaton decorator that maps states to their scc-number. More...

class	scc_impl
	Class template for strongly-connected-components computations. More...

class	scc_impl< Aut, auto_tag >
	By default, use Tarjan iterative. More...

class	scc_impl< Aut, dijkstra_tag >
	Compute the strongly connected components using Dijkstra's algorithm. More...

class	scc_impl< Aut, kosaraju_tag >
	Compute the strongly connected components using Kosaraju's algorithm. More...

class	scc_impl< Aut, tarjan_iterative_tag >
	Tarjan's algorithm to find all strongly connected components: iterative implementation. More...

class	scc_impl< Aut, tarjan_recursive_tag >
	Tarjan's algorithm to find all strongly connected components: recursive implementation. More...

struct	select

struct	select< q >

struct	select< r >

struct	select< z >

class	sorter
	A function to sort an automaton. More...

struct	standard_operations
	Implementation of left- and right- multiplication of an automaton by a weight. More...

class	star_height_visitor

class	state_bimap
	A bidirectional map from state names to state numbers. More...

class	state_bimap< StateNameset, Stateset, false >
	A bidirectional map from state names to state numbers. More...

class	state_bimap< StateNameset, Stateset, true >
	A bidirectional map from state names to state numbers. More...

struct	state_eliminator
	Eliminate states in an automaton. More...

struct	state_t_of_impl

struct	state_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::state_t > >

struct	state_t_of_impl< ValueSet *, void_t< typename ValueSet::state_t > >

struct	state_t_of_impl< ValueSet, void_t< typename ValueSet::state_t > >

class	synchronize_checker

class	synchronized_automaton_impl
	An automaton whose states may be qualified by delays and/or prefixes. More...

class	synchronizer

class	tikzer
	Format automaton to TikZ format. More...

struct	transition_less
	Compare transitions of an automaton. More...

class	transition_map
	Cache the outgoing transitions of an automaton as efficient maps label -> vector<(weight, dst)>. More...

struct	transition_t_of_impl

struct	transition_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::transition_t > >

struct	transition_t_of_impl< ValueSet *, void_t< typename ValueSet::transition_t > >

struct	transition_t_of_impl< ValueSet, void_t< typename ValueSet::transition_t > >

class	transpose_automaton_impl
	Read-write view on an automaton, that transposes everything. More...

class	transpose_impl
	A visitor to create a transposed expression,. More...

class	trie_builder
	Build a trie automaton (prefix-tree-like automaton). More...

class	tuple_automata_impl
	Build the (accessible part of the) Cartesian product of automata. More...

class	tuple_automaton_impl
	An automaton whose states are tuples of states of automata. More...

struct	tuple_printer

struct	tuple_printer< Tuple, 1 >

class	tupleset_impl
	A ValueSet which is a Cartesian product of ValueSets. More...

class	universal_impl
	Functor for universal. More...

struct	voider

struct	weight_t_of_impl

struct	weight_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::weight_t > >

struct	weight_t_of_impl< ValueSet *, void_t< typename ValueSet::weight_t > >

struct	weight_t_of_impl< ValueSet, void_t< typename ValueSet::weight_t > >

struct	weightset_t_of_impl

struct	weightset_t_of_impl< std::shared_ptr< ValueSet >, void_t< typename ValueSet::weightset_t > >

struct	weightset_t_of_impl< ValueSet *, void_t< typename ValueSet::weightset_t > >

struct	weightset_t_of_impl< ValueSet, void_t< typename ValueSet::weightset_t > >

struct	welement_label
	Storage for a label. More...

struct	welement_label< empty_t >
	Storage for a label in the case of the empty labelset. More...

struct	welement_weight
	Storage for a non-null weight. More...

struct	welement_weight< bool >
	Storage for a non-null single-bit weight: don't actually store anything. More...

class	wet_bitset
	Weighted set: labels are non-negative integers, weights are bools. More...

struct	wet_kind_impl
	wet_impl<Key, Value>: map. More...

struct	wet_kind_impl< char, bool >
	wet_impl<char, bool>: bitsets. More...

struct	wet_kind_impl< Key, bool >
	wet_impl<Key, bool>: set. More...

class	wet_map
	Weighted set: general, ordered, case. More...

class	wet_set
	Weighted set: weights are bools. More...

class	wet_unordered_map
	Weighted set: general, unordered, case. More...

class	word_synchronizer

struct	worded_automaton

struct	yen_impl
	Yen implementation of the K lightest automaton algorithm. More...

class	z_impl

class	zmin_impl

Typedefs
template<Automaton Aut>
using	res_labelset_t_of = typename res_labelset_t_of_impl< Aut >::type

template<Automaton Aut>
using	res_label_t_of = typename res_label_t_of_impl< Aut >::type

template<Automaton Aut>
using	full_context_t_of = typename full_context_t_of_impl< Aut >::type

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<Automaton Aut>
using	determinization_tag = std::conditional_t< std::is_same< weight_t_of< Aut >, bool >::value, boolean_tag, weighted_tag >
	The best tag depending on the type of Aut. More...

template<Automaton Aut>
using	insplit_automaton = std::shared_ptr< insplit_automaton_impl< Aut >>
	An insplit automaton as a shared pointer. More...

template<Automaton Aut>
using	letterized_ls = letterized_traits< labelset_t_of< Aut >>

template<typename Ctx , size_t... Tapes>
using	lifter_t = lifter_impl< Ctx, detail::index_sequence< Tapes... >>
	A traits to lift the Tapes of the labels to the weights. More...

template<Automaton Aut, size_t... Tapes>
using	lifted_automaton_t = mutable_automaton< typename lifter_t< context_t_of< Aut >, Tapes... >::context_t >

template<typename ExpSet >
using	lifted_expressionset_t = expressionset< typename lifter_t< context_t_of< ExpSet >>::context_t >

template<Automaton Aut>
using	has_fado_t = std::integral_constant< bool,((context_t_of< Aut >::is_lal\|\|context_t_of< Aut >::is_lan\|\|context_t_of< Aut >::is_lat)&&std::is_same< weightset_t_of< Aut >, b >::value)>

template<Automaton Aut>
using	has_grail_t = std::integral_constant< bool,((context_t_of< Aut >::is_lal\|\|context_t_of< Aut >::is_lan)&&std::is_same< weightset_t_of< Aut >, b >::value)>

template<Automaton Aut>
using	component_t = std::unordered_set< state_t_of< Aut >>
	A strongly-connected component: set of states. More...

template<Automaton Aut>
using	components_t = std::vector< component_t< Aut >>
	A set of strongly-connected components. More...

template<Automaton Aut>
using	fresh_worded_automaton_t = fresh_automaton_t_of< typename worded_automaton< Aut >::automaton_t >

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

template<Automaton... Auts>
using	join_automata_t = decltype(join_automata< std::declval< Auts >()... >)
	The type of the join between automata of type Auts. More...

template<Automaton Aut>
using	origins_t_of = typename origins_t_of_impl< Aut >::type
	The type of the origins map for a partition automaton, or a transposed one. More...

template<Automaton Aut, wet_kind_t Kind = wet_kind<labelset_t_of<Aut>, weightset_t_of<Aut>>(), bool Lazy = false>
using	polystate_automaton = std::shared_ptr< polystate_automaton_impl< Aut, Kind, Lazy >>
	A polystate automaton as a shared pointer. More...

template<typename LabelSet >
using	generators_mem_fn_t = decltype(std::declval< LabelSet >().generators())
	The type of the LabelSet::generators() member function. More...

template<typename LabelSet >
using	has_generators_mem_fn = detect< LabelSet, generators_mem_fn_t >
	Whether LabelSet features a generators() member function. More...

template<typename LabelSet >
using	one_t = decltype(std::declval< LabelSet >().one())

template<typename LabelSet >
using	has_one_mem_fn = detect< LabelSet, one_t >

template<typename LabelSet >
using	letterized_t = typename letterized_traits< LabelSet >::labelset_t

template<typename LabelSet >
using	is_letterized_t = bool_constant< letterized_traits< LabelSet >::is_letterized >

template<typename Context >
using	letterized_context = context< letterized_t< labelset_t_of< Context >>, weightset_t_of< Context >>

template<typename LabelSet >
using	nullableset_t = typename nullableset_traits< LabelSet >::type
	The smallest nullableset that includes LabelSet. More...

template<typename Ctx >
using	nullableset_context_t = context< nullableset_t< labelset_t_of< Ctx >>, weightset_t_of< Ctx >>

template<typename LabelSet >
using	proper_t = typename proper_traits< LabelSet >::type
	The type of the corresponding proper LabelSet. More...

template<typename Context >
using	proper_context = context< proper_t< labelset_t_of< Context >>, weightset_t_of< Context >>

template<typename Context >
using	free_context = context< proper_t< letterized_t< labelset_t_of< Context >>>, weightset_t_of< Context >>

template<typename LabelSet >
using	law_t = typename law_traits< LabelSet >::type
	The smallest wordset that includes LabelSet. More...

template<typename Ctx >
using	word_context_t = context< law_t< labelset_t_of< Ctx >>, weightset_t_of< Ctx >>

template<typename... ValueSets>
using	labelset_types = labelset_types_impl< void, ValueSets... >

template<size_t Tape, typename LabelSet >
using	project_labelset = typename project_labelset_impl< Tape, LabelSet >::type
	The type of the resulting apparent LabelSet when keeping only tape Tape. More...

template<size_t Tape, typename Context >
using	project_context = context< project_labelset< Tape, labelset_t_of< Context >>, weightset_t_of< Context >>
	The type of the resulting apparent context when keeping only tape Tape. More...

template<typename Ctx >
using	word_polynomialset_t = polynomialset< word_context_t< Ctx >>

template<typename T >
using	test_t = decltype(std::declval< T >().size())

template<typename T >
using	has_size_mem_fn = detect< T, test_t >
	Whether T features a size() function. More...

template<typename S1 , typename S2 >
using	Concat = typename concat< S1, S2 >::type

template<std::size_t N>
using	GenSeq = typename make_index_sequence< N >::type

template<std::size_t S, std::size_t E>
using	make_index_range_t = typename make_index_range< S, E >::type

template<typename S1 , typename S2 >
using	concat_sequence = typename concat_index_sequence< S1, S2 >::type

template<typename S1 , typename S2 >
using	sequence_difference = typename index_sequence_difference< typename S1::type, typename S2::type >::type

template<typename... Ts>
using	void_t = typename voider< Ts... >::type

template<wet_kind_t Kind, typename Key , typename Value , typename Compare , typename Hash , typename KeyEqual >
using	wet_impl = std::conditional_t< Kind==wet_kind_t::bitset, wet_bitset, std::conditional_t< Kind==wet_kind_t::set, wet_set< Key, Compare >, std::conditional_t< Kind==wet_kind_t::map, wet_map< Key, Value, Compare >, std::conditional_t< Kind==wet_kind_t::unordered_map, wet_unordered_map< Key, Value, Hash, KeyEqual >, void > > > >
	A weighted set type from its kind. More...

template<typename T >
using	power_mem_fn_t = decltype(std::declval< T >().power(std::declval< typename T::value_t >(), 0))
	The signature of power. More...

template<typename T >
using	has_power_mem_fn = detail::detect< T, power_mem_fn_t >
	Whether T features a power member function. More...

Functions
template<Automaton Aut>
boost::optional< std::vector< transition_t_of< Aut > > >	bellman_ford_impl (const Aut &aut, state_t_of< Aut > source)
	Bellman-Ford implementation of lightest automaton. More...

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

template<Automaton Aut, Automaton... Auts>
auto	conjunction (const Aut &a, const Auts &...as)
	Build the (accessible part of the) conjunction. More...

template<Automaton Aut, Automaton... Auts>
auto	conjunction_lazy (const Aut &a, const Auts &...as)
	Build the (accessible part of the) conjunction, on-the-fly. More...

template<Automaton Aut>
auto	real_context (const Aut &aut) -> decltype(real_context_impl< Aut >::context(aut))
	For a focus automaton, its genuine context (not the visible one), and for all the other automata, their context. More...

template<Automaton Aut, typename ValueSet , typename Mul >
auto	make_dijkstra_impl (const Aut &aut, const ValueSet &vs, Mul mul)

template<Automaton Aut>
ATTRIBUTE_CONST std::enable_if_t<!labelset_t_of< Aut >::has_one(), size_t >	num_spontaneous_transitions (const Aut &)

template<Automaton Aut>
std::enable_if_t< labelset_t_of< Aut >::has_one(), size_t >	num_spontaneous_transitions (const Aut &aut)

template<Automaton Aut>
size_t	num_lazy_states (const Aut &a)

template<Automaton Aut>
auto	make_insplit_automaton (const Aut &aut) -> insplit_automaton< Aut >
	Build an insplit automaton from an automaton. More...

template<Automaton Aut>
auto	insplit (Aut aut, bool lazy=false) -> std::enable_if_t< labelset_t_of< Aut >::has_one(), decltype(make_insplit_automaton(aut))>
	Insplit an automaton with possible spontaneous transitions. More...

template<Automaton Aut>
std::enable_if_t< labelset_t_of< Aut >::has_one(), bool >	is_proper_ (const Aut &aut)

template<Automaton Aut>
constexpr std::enable_if_t<!labelset_t_of< Aut >::has_one(), bool >	is_proper_ (const Aut &)

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

template<Automaton Aut>
delay_automaton< Aut >	make_delay_automaton (const Aut &aut)

template<Automaton Aut>
fresh_automaton_t_of< Aut >	absval (const Aut &aut)
	Copy of aut, with absolute values. More...

template<Automaton Aut>
bool	is_properable (Aut &&aut)
	Whether proper_here(aut) succeeds. More...

template<Automaton Aut, typename ValueSet , typename Mul , typename GetValue >
auto	make_yen (const Aut &aut, const ValueSet &vs, Mul mul, GetValue get_value)

template<Automaton Aut>
std::enable_if_t<!is_letterized_t< labelset_t_of< Aut > >{}, mutable_automaton< letterized_context< context_t_of< Aut > > > >	letterize (const Aut &aut)
	Letterize an automaton whose type is not letterized already. More...

template<Automaton Aut>
std::enable_if_t< is_letterized_t< labelset_t_of< Aut > >{}, const Aut & >	letterize (const Aut &aut)
	Letterize an automaton whose type is letterized: do nothing. More...

template<Automaton Aut>
std::enable_if_t<!is_letterized_t< labelset_t_of< Aut > >{}, bool >	is_letterized (const Aut &aut)

template<Automaton Aut>
std::enable_if_t< is_letterized_t< labelset_t_of< Aut > >{}, bool >	is_letterized (const Aut &)

static labelset_t::value_t	kept_label (const in_label_t &l)
	Label in the output. More...

template<size_t... I>
static labelset_t::value_t	kept_label_ (const in_label_t &l, seq< I... >)

static weight_tapes_t::value_t	weight_label (const in_label_t &l)
	Weight in the output. More...

template<size_t... I>
static weight_tapes_t::value_t	weight_label_ (const in_label_t &l, seq< I... >)

template<typename LabelSet , typename WeightSet , size_t... Tapes>
lifter_t< context< LabelSet, WeightSet >, Tapes... >::context_t	lift_context (const context< LabelSet, WeightSet > &ctx)
	lift(ctx) -> ctx More...

template<typename Context >
lifted_expressionset_t< expressionset< Context > >	lift_expressionset (const expressionset< Context > &rs, boost::optional< vcsn::rat::identities > ids={})
	lift(expressionset) -> expressionset More...

template<Automaton Aut, typename Tag >
std::vector< transition_t_of< Aut > >	lightest_path_tag (const Aut &aut, state_t_of< Aut > src, state_t_of< Aut > dst)
	Tag-based dispatch on implementation. More...

template<Automaton Aut>
auto	fado_impl_ (const Aut &aut, std::ostream &out) -> std::enable_if_t< has_fado_t< Aut >

template<Automaton Aut>
ATTRIBUTE_NORETURN auto	fado_impl_ (const Aut &, std::ostream &) -> std::enable_if_t<!has_fado_t< Aut >

template<Automaton Aut>
auto	grail_impl_ (const Aut &aut, std::ostream &out) -> std::enable_if_t< has_grail_t< Aut >

template<Automaton Aut>
ATTRIBUTE_NORETURN auto	grail_impl_ (const Aut &, std::ostream &) -> std::enable_if_t<!has_grail_t< Aut >

template<size_t Tape, typename Context >
auto	project (const expressionset< Context > &rs)
	Project an expressionset to one tape. More...

template<size_t Tape, typename ValueSet >
auto	project (const ValueSet &vs, const typename ValueSet::value_t &v)
	Project a value to one tape. More...

template<size_t Tape, typename Context , wet_kind_t Kind>
auto	project (const polynomialset< Context, Kind > &ps)
	Project a polynomialset to one tape. More...

template<Automaton Aut>
auto	make_properer (Aut aut, bool prune=true, const std::string &algo="auto")

template<typename ExpressionSet , typename RandomGenerator = std::mt19937>
random_expression_impl< ExpressionSet, RandomGenerator >	make_random_expression_impl (const ExpressionSet &rs, const std::string &param, RandomGenerator &gen=make_random_engine())
	Convenience constructor. More...

template<Automaton Aut>
auto	strip (const Aut &aut, int) -> decltype(aut->strip())

template<Automaton Aut>
auto	strip (const Aut &aut, long) -> decltype(aut)

template<Automaton Aut>
synchronizer< Aut >::out_automaton_t	synchronize (const Aut &aut)

template<Automaton... Aut, typename Operation >
auto	dispatch_tags (std::string algo, Operation op, Aut &&...auts)
	Dispatch an operation between automata depending on their nature. More...

template<Automaton... Auts>
auto	make_join_automaton (deterministic_tag, Auts &&...auts) -> decltype(join_automata(std::forward< Auts >(auts)...))
	Make an empty automaton which is a supertype of others. More...

template<Automaton... Auts>
auto	make_join_automaton (general_tag, Auts &&...auts) -> decltype(nullable_join_automata(std::forward< Auts >(auts)...))
	Make an empty automaton which is a supertype of others, and with a nullable labelset. More...

template<Automaton... Auts>
auto	make_join_automaton (standard_tag, Auts &&...auts) -> decltype(join_automata(std::forward< Auts >(auts)...))
	Make an empty automaton which is a supertype of others. More...

template<Automaton Aut, typename Profiler >
state_eliminator< Aut, Profiler >	make_state_eliminator (Aut &a, Profiler &profiler)

template<typename ExpSet >
auto	letter_class_impl (const ExpSet &, const letter_class_t &, bool, std::false_type, std::true_type) -> typename ExpSet::value_t

template<typename ExpSet >
auto	letter_class_impl (const ExpSet &rs, const letter_class_t &chars, bool accept, std::false_type, std::false_type) -> typename ExpSet::value_t

template<typename ExpSet >
auto	letter_class_impl (const ExpSet &rs, const letter_class_t &, bool, std::true_type, std::false_type) -> typename ExpSet::value_t

std::string	quote (const std::string &s)
	Turn a label into a parsable label: escape special characters. More...

template<direction Dir, typename PolynomialSet >
trie_builder< free_context< context_t_of< PolynomialSet > >, Dir >	make_trie_builder (const PolynomialSet &ps)
	Instantiate a trie-builder for this type of polynomialset. More...

template<Automaton... Auts>
auto	tuple (const Auts &...as)
	Build the (accessible part of the) tuple. More...

template<Automaton Aut>
size_t	states_size (const Aut &aut)
	The largest state number, plus one. More...

template<Automaton Aut>
size_t	transitions_size (const Aut &aut)
	The largest transition number, plus one. More...

template<Automaton Aut>
auto	all_out (const Aut &aut, state_t_of< Aut > s)
	Indexes of transitions leaving state s. More...

template<Automaton Aut, typename Pred >
auto	all_out (const Aut &aut, state_t_of< Aut > s, Pred pred)
	Indexes of transitions leaving state s that validate the predicate. More...

template<Automaton Aut>
auto	out (const Aut &aut, state_t_of< Aut > s)
	Indexes of visible transitions leaving state s. More...

template<Automaton Aut>
auto	out (const Aut &aut, state_t_of< Aut > s, label_t_of< Aut > l)
	Indexes of all transitions leaving state s on label l. More...

template<Automaton Aut>
auto	all_in (const Aut &aut, state_t_of< Aut > s)
	Indexes of transitions entering state s. More...

template<Automaton Aut, typename Pred >
auto	all_in (const Aut &aut, state_t_of< Aut > s, Pred pred)
	Indexes of transitions entering state s that validate the predicate. More...

template<Automaton Aut>
auto	in (const Aut &aut, state_t_of< Aut > s)
	Indexes of visible transitions arriving to state s. More...

template<Automaton Aut>
auto	in (const Aut &aut, state_t_of< Aut > s, label_t_of< Aut > l)
	Indexes of visible transitions arriving to state s on label l. More...

template<Automaton Aut>
auto	initial_transitions (const Aut &aut) -> decltype(aut->all_out(aut->pre()))
	Indexes of transitions to (visible) initial states. More...

template<Automaton Aut>
auto	final_transitions (const Aut &aut) -> decltype(aut->all_in(aut->post()))
	Indexes of transitions from (visible) final states. More...

template<Automaton Aut>
auto	outin (const Aut &aut, state_t_of< Aut > s, state_t_of< Aut > d)
	Indexes of visible transitions from state s to state d. More...

template<Automaton Aut>
void	del_transition (const Aut &aut, state_t_of< Aut > s, state_t_of< Aut > d)
	Remove all the transitions between s and d. More...

template<Automaton Aut>
auto	all_transitions (const Aut &aut)
	All the transition indexes between all states (including pre and post). More...

template<Automaton Aut, typename Pred >
auto	all_transitions (const Aut &aut, Pred pred)
	All the transition indexes between all states (including pre and post), that validate pred. More...

template<Automaton Aut>
bool	is_special (const Aut &aut, transition_t_of< Aut > t)
	Whether this transition is from pre or to post. More...

template<Automaton Aut>
auto	transitions (const Aut &aut) -> decltype(all_transitions(aut, is_special_t< Aut >
	All the transition indexes between visible states. More...

template<Automaton... Auts>
auto	join_automata (Auts &&...auts) -> decltype(pass(auts->null_state()...), make_mutable_automaton(join(auts->context()...)))
	An automaton whose type is the join between those of auts. More...

template<Automaton... Auts>
auto	nullable_join_context (Auts &&...auts) -> decltype(pass(auts->null_state()...), make_nullableset_context(join(auts->context()...)))
	The nullable context of the join between parameters' context. More...

template<Automaton... Auts>
auto	nullable_join_automata (Auts &&...auts) -> decltype(pass(auts->null_state()...), make_mutable_automaton(nullable_join_context(auts...)))
	An automaton whose type is the nullable join between those of auts. More...

template<Automaton... Auts>
auto	meet_automata (Auts &&...auts) -> decltype(pass(auts->null_state()...), make_mutable_automaton(meet(auts->context()...)))
	An automaton whose type is the meet between those of auts. More...

template<typename V1 , typename V2 >
join_impl< V1, V2 >::type	join_ (V1 v1, V2 v2, int)
	Dealing with commutativity: two implementations of join_: forward and reversed, ordered by preference by the use of "0 prefers int to long" disambiguation rule. More...

template<typename V1 , typename V2 >
join_impl< V1, V2 >::type	join_ (V2 v2, V1 v1, long)

template<Automaton Aut, wet_kind_t Kind = wet_kind<labelset_t_of<Aut>, weightset_t_of<Aut>>(), bool Lazy = false>
auto	make_polystate_automaton (const Aut &aut)

template<size_t Tape, typename LabelSet , typename WeightSet >
auto	project (const context< LabelSet, WeightSet > &ctx) -> std::enable_if_t< is_multitape< LabelSet >
	The resulting apparent context when keeping only tape Tape. More...

template<typename LabelSet >
auto	label_one (const LabelSet &ls) -> typename LabelSet::value_t
	Enjoy type inference. More...

template<typename LabelSet >
letterized_t< LabelSet >	make_letterized (const LabelSet &ls)

template<typename LabelSet , typename WeightSet >
letterized_context< context< LabelSet, WeightSet > >	make_letterized_context (const context< LabelSet, WeightSet > &c)
	The letterized context for c. More...

template<typename LabelSet >
nullableset_t< LabelSet >	make_nullableset (const LabelSet &ls)
	The nullableset of a labelset. More...

template<typename LabelSet , typename WeightSet >
nullableset_context_t< context< LabelSet, WeightSet > >	make_nullableset_context (const context< LabelSet, WeightSet > &ctx)
	The nullableset context of a context. More...

template<typename LabelSet >
proper_t< LabelSet >	make_proper (const LabelSet &ls)
	The corresponding proper LabelSet. More...

template<typename LabelSet , typename WeightSet >
auto	make_proper_context (const context< LabelSet, WeightSet > &ctx) -> proper_context< context< LabelSet, WeightSet >>
	From a context, its non-nullable context. More...

template<typename LabelSet , typename WeightSet >
free_context< context< LabelSet, WeightSet > >	make_free_context (const context< LabelSet, WeightSet > &c)
	The free context for c. More...

template<typename LabelSet >
law_t< LabelSet >	make_wordset (const LabelSet &ls)
	The wordset of a labelset. More...

template<typename LabelSet , typename WeightSet >
word_context_t< context< LabelSet, WeightSet > >	make_word_context (const context< LabelSet, WeightSet > &ctx)
	The wordset context of a context. More...

template<typename LabelSet >
std::ostream &	print_label_ranges_ (const LabelSet &ls, const std::vector< typename LabelSet::value_t > &letters, const std::vector< typename LabelSet::value_t > &alphabet, std::ostream &out, format fmt)
	Print a set of labels with ranges. More...

template<typename LabelSet >
std::ostream &	print_label_class (const LabelSet &ls, const std::vector< typename LabelSet::value_t > &letters, std::ostream &out, format fmt)
	Print a set of labels (letterized) with classes. More...

template<typename LabelSet >
LabelSet::letters_t	conv_label_class_ (const LabelSet &ls, std::istream &i)
	Read a set of letters (hence, guaranteed in order, and unique). More...

template<typename LabelSet , typename Fun >
void	conv_label_class_ (const LabelSet &ls, std::istream &i, Fun fun)
	Read and process a class of letters. More...

template<typename... ValueSets>
tupleset< ValueSets... >	make_tupleset (const ValueSets &...vss)

template<typename Ctx >
auto	make_word_polynomialset (const Ctx &ctx) -> word_polynomialset_t< Ctx >
	The polynomialset of words of a labelset (not necessarily on words itself). More...

template<typename Range , typename Predicate >
bool	any_of (const Range &r, Predicate p)

template<typename Range >
bool	any_of (const Range &r)

template<typename Container >
Container::value_type	back (const Container &container)
	The last member of this Container. More...

template<typename Container , typename Predicate >
void	erase_if (Container &c, const Predicate &p)

template<typename Container >
Container::value_type	front (const Container &container)
	The first member of this Container. More...

template<typename Iterator , typename Pred , typename Less >
boost::iterator_range< Iterator >	initial_sorted_range (Iterator begin, Iterator end, Pred pred, Less less)
	The longest initial range of elements matching the predicate. More...

template<typename Container , typename Compare >
bool	is_sorted_forward (const Container &container, Compare comp)
	Same as std::is_sorted, but works with an input iterator, not just a forward iterator. More...

template<typename Container >
Container::value_type	max_forward (const Container &container)
	Same as `*std::max_element`, but works with an input iterator, not just a forward iterator. More...

template<typename Range , typename Predicate >
bool	none_of (const Range &r, Predicate p)

template<typename Range , typename Value >
bool	none_of_equal (const Range &r, const Value &value)

template<typename Container , typename Fun >
auto	transform (const Container &c, Fun &&fun)
	Map a unary function on a container of values, and return the vector the results. More...

template<typename T >
T	lexical_cast (const std::string &str)
	String to templated type T conversion. More...

static int	debug_level ()
	Debug level set in the user's environment. More...

template<typename T >
auto	hash_value (const T &v) -> decltype(std::hash< T >
	Following the naming convention of Boost. More...

return	hasher (v)

template<typename C >
ATTRIBUTE_NORETURN void	invalid_argument (const std::string &kind, const std::string &key, const C &map)

template<typename Integer >
auto	irange (Integer last)
	Generate an integer range. More...

ATTRIBUTE_PURE unsigned int	gcd (unsigned int a, unsigned int b)
	Greatest common divisor. More...

ATTRIBUTE_PURE unsigned int	lcm (unsigned int a, unsigned int b)
	Lowest common multiple. More...

template<typename Range >
std::queue< typename Range::value_type >	make_queue (const Range &range)
	The content of cont as a queue. More...

template<typename T >
void	print_ (std::ostream &o, const T &arg, long)
	Serialize arg into o. More...

void	print_ (std::ostream &o, std::istream &is, long)
	When printing an istream, consider that we are trying to help the user by showing what's wrong with the input. More...

void	print_ (std::ostream &o, std::istringstream &is, long)
	Disambiguation: both 'istream&' and 'const T&' are elligible. More...

template<typename T >
auto	print_ (std::ostream &o, const T &arg, int) -> decltype(arg.print_set(o), void())
	Serialize arg, which supports print_set, into o. More...

template<typename Then , typename Else >
auto	static_if (std::true_type, Then &&then, Else &&)
	Execute the then-clause. More...

template<typename Then , typename Else >
auto	static_if (std::false_type, Then &&, Else &&else_)
	Execute the else-clause. More...

template<bool cond, typename Then , typename Else >
auto	static_if (Then &&then, Else &&else_)
	Execute the then- or the else-clause depending on cond. More...

template<bool cond, typename Then >
auto	static_if (Then &&then)
	Execute the then-clause if cond is verified. More...

template<typename Fun , typename... Ts>
void	for_ (const std::tuple< Ts... > &ts, Fun f)

template<typename Fun , typename... Ts, size_t... I>
void	for_ (Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >)

template<typename Fun , typename... Ts>
auto	map (const std::tuple< Ts... > &ts, Fun f) -> decltype(map_tuple_(f, ts, make_index_sequence< sizeof...(Ts)>()))
	Map a function on a tuple, return tuple of the results. More...

template<typename Fun , typename... Ts, size_t... I>
auto	map_impl_ (Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >)

template<typename Fun , typename... Args>
auto	apply (Fun f, const std::tuple< Args... > &args) -> decltype(apply_impl_(f, args, make_index_sequence< sizeof...(Args)>()))
	Unpack a tuple, and pass its content as argument to a funtion. More...

template<typename Fun , typename... Args, size_t... I>
auto	apply_impl_ (Fun f, const std::tuple< Args... > &args, index_sequence< I... >) -> decltype(f(std::get< I >(args)...))

template<typename... Funs, typename... Args>
auto	apply (const std::tuple< Funs... > &funs, const std::tuple< Args... > &args)
	Apply a tuple of functions on a tuple of arguments, return the tuple of results. More...

template<typename... Funs, typename... Args, size_t... I>
auto	apply_impl_ (const std::tuple< Funs... > &funs, const std::tuple< Args... > &args, index_sequence< I... >)
	Apply a tuple of functions on a tuple of arguments, return the tuple of results. More...

template<typename Fun , typename... Objs, typename... Args>
auto	apply (Fun fun, const std::tuple< Objs... > &objs, const std::tuple< Args... > &args)
	Apply a tuple of member functions on a tuple of arguments, return the tuple of results. More...

template<typename Fun , typename... Objs, typename... Args, size_t... I>
auto	apply_impl_ (Fun fun, const std::tuple< Objs... > &objs, const std::tuple< Args... > &args, index_sequence< I... >)

template<typename Fun >
void	cross (Fun f)
	Variadic Cartesian product of containers. More...

template<typename Fun , typename Cont , typename... Conts>
void	cross (Fun f, const Cont &head, const Conts &...tails)

template<typename Fun , typename... Ts, size_t... I>
void	cross_tuple_ (Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >)

template<typename Fun , typename... Ts>
void	cross_tuple (Fun f, const std::tuple< Ts... > &ts)

template<typename... Ts>
auto	reverse_tuple (const std::tuple< Ts... > &t) -> decltype(reverse_tuple(t, make_index_sequence< sizeof...(Ts)>()))

template<typename... Ts, std::size_t... I>
auto	reverse_tuple (const std::tuple< Ts... > &t, index_sequence< I... >) -> decltype(std::make_tuple(std::get< sizeof...(Ts)-1-I >(t)...))

template<typename... Ts>
auto	make_gcc_tuple (Ts &&...ts) -> decltype(reverse_tuple(std::make_tuple(std::forward< Ts >(ts)...)))
	Same as make_tuple, unless the evaluation of arguments if right-to-left, in which case reverse the result. More...

template<typename... Args>
std::ostream &	print (const std::tuple< Args... > &args, std::ostream &o)

template<typename Cont >
std::vector< typename Cont::value_type >	make_vector (const Cont &cont)
	The content of cont as a vector. More...

template<typename Key , typename Value >
constexpr wet_kind_t	wet_kind ()
	Given a Key and a Value type, the appropriate weighted set type. More...

	VCSN_JOIN_SIMPLE (b, b)

template<typename Context , wet_kind_t Kind = detail::wet_kind<labelset_t_of<Context>, weightset_t_of<Context>>()>
polynomialset< Context, Kind >	make_polynomialset (const Context &context)

Variables
template<typename... LabelSets, typename WeightSet , size_t... Tapes>
struct lifter_impl< context< tupleset< LabelSets... >, WeightSet >, vcsn::detail::index_sequence< Tapes... >, std::enable_if_t<(0< sizeof...(Tapes))> >{using in_labelset_t=tupleset< LabelSets... >;using in_context_t=context< in_labelset_t, WeightSet >;using in_label_t=typename in_labelset_t::value_t;template< std::size_t...I > using seq=detail::index_sequence< I... >;template< typename S, typename L > struct tape_set;template< typename LabelSet > struct tape_set< seq<>, LabelSet >{using type=oneset;};template< size_t...I, typename LabelSet > struct tape_set< seq< I... >, LabelSet >{using type=tupleset< typename LabelSet::template valueset_t< I >... >;};using index_t=typename detail::make_index_sequence< in_labelset_t::size()>::type;static constexpr size_t number_of_tapes=in_labelset_t::size();template< size_t I > using tape_labelset_t=typename in_labelset_t::template valueset_t< I >;using kept_index_t=sequence_difference< index_t, seq< Tapes... > >;using labelset_t=typename tape_set< kept_index_t, in_labelset_t >::type;using weight_index_t=seq< Tapes... >;using weight_tapes_t=typename tape_set< weight_index_t, in_labelset_t >::type;using inner_context_t=context< weight_tapes_t, WeightSet >;using weightset_t=expressionset< inner_context_t >;using context_t=context< labelset_t, weightset_t >;static context_t value(const in_context_t &ctx, vcsn::rat::identities ids){return value_(ctx, ids, weight_index_t{}, kept_index_t{});}template< size_t...WeightTapes, size_t...KeptTapes > static context_t value_(const in_context_t &ctx, vcsn::rat::identities ids, seq< WeightTapes... >, seq< KeptTapes... >){auto ls=labelset_t{ctx.labelset() -> template	set< KeptTapes > ()...}
	Specialization: lift only some tapes. More...

auto	weight_tapes = weight_tapes_t{ctx.labelset()->template set<WeightTapes>()...}

auto	ictx = inner_context_t{weight_tapes, *ctx.weightset()}

auto	rs = weightset_t{ictx, ids}

	return {ls, rs}

	void

	project_context< Tape, context< LabelSet, WeightSet > >

	context< LabelSet, WeightSet >

return	ctx

	v

xalloc< long int >	indentation

Typedef Documentation

template<Automaton Aut>

using vcsn::detail::component_t = typedef std::unordered_set<state_t_of<Aut>>

A strongly-connected component: set of states.

Benches show that using std::unordered_set is better than std::set about ~10x. For example: std::set: 5.53s: a.scc("tarjan_iterative") # a = std((abc)*{1000}) std::unordered_set: 0.58s: a.scc("tarjan_iterative") # a = std((abc)*{1000})

Definition at line 41 of file scc.hh.

template<Automaton Aut>

using vcsn::detail::components_t = typedef std::vector<component_t<Aut>>

A set of strongly-connected components.

Definition at line 45 of file scc.hh.

template<typename S1 , typename S2 >

using vcsn::detail::Concat = typedef typename concat<S1, S2>::type

Definition at line 40 of file tuple.hh.

template<typename S1 , typename S2 >

using vcsn::detail::concat_sequence = typedef typename concat_index_sequence<S1, S2>::type

Definition at line 100 of file tuple.hh.

template<Automaton Aut>

using vcsn::detail::determinization_tag = typedef std::conditional_t<std::is_same<weight_t_of<Aut>, bool>::value, boolean_tag, weighted_tag>

The best tag depending on the type of Aut.

Definition at line 267 of file determinize.hh.

template<typename Context >

using vcsn::detail::free_context = typedef context<proper_t<letterized_t<labelset_t_of<Context>>>, weightset_t_of<Context>>

Definition at line 231 of file labelset.hh.

template<Automaton Aut>

using vcsn::detail::fresh_worded_automaton_t = typedef fresh_automaton_t_of<typename worded_automaton<Aut>::automaton_t>

Definition at line 72 of file synchronize.hh.

template<Automaton Aut>

using vcsn::detail::full_context_t_of = typedef typename full_context_t_of_impl<Aut>::type

Definition at line 38 of file compose.hh.

template<typename LabelSet >

using vcsn::detail::generators_mem_fn_t = typedef decltype(std::declval<LabelSet>().generators())

The type of the LabelSet::generators() member function.

Definition at line 24 of file labelset.hh.

template<std::size_t N>

using vcsn::detail::GenSeq = typedef typename make_index_sequence<N>::type

Definition at line 44 of file tuple.hh.

template<Automaton Aut>

using vcsn::detail::has_fado_t = typedef std::integral_constant<bool, ((context_t_of<Aut>::is_lal || context_t_of<Aut>::is_lan || context_t_of<Aut>::is_lat) && std::is_same<weightset_t_of<Aut>, b>::value)>

Definition at line 35 of file print.hh.

template<typename LabelSet >

using vcsn::detail::has_generators_mem_fn = typedef detect<LabelSet, generators_mem_fn_t>

Whether LabelSet features a generators() member function.

Definition at line 28 of file labelset.hh.

template<Automaton Aut>

using vcsn::detail::has_grail_t = typedef std::integral_constant<bool, ((context_t_of<Aut>::is_lal || context_t_of<Aut>::is_lan) && std::is_same<weightset_t_of<Aut>, b>::value)>

Definition at line 41 of file print.hh.

template<typename LabelSet >

using vcsn::detail::has_one_mem_fn = typedef detect<LabelSet, one_t>

Definition at line 39 of file labelset.hh.

template<typename T >

using vcsn::detail::has_power_mem_fn = typedef detail::detect<T, power_mem_fn_t>

Whether T features a power member function.

Definition at line 42 of file weightset.hh.

template<typename T >

using vcsn::detail::has_size_mem_fn = typedef detect<T, test_t>

Whether T features a size() function.

Definition at line 17 of file military-order.hh.

template<Automaton Aut>

using vcsn::detail::insplit_automaton = typedef std::shared_ptr<insplit_automaton_impl<Aut>>

An insplit automaton as a shared pointer.

Definition at line 251 of file insplit.hh.

template<typename LabelSet >

using vcsn::detail::is_letterized_t = typedef bool_constant<letterized_traits<LabelSet>::is_letterized>

Definition at line 97 of file labelset.hh.

template<Automaton... Auts>

using vcsn::detail::join_automata_t = typedef decltype(join_automata<std::declval<Auts>()...>)

The type of the join between automata of type Auts.

Definition at line 23 of file join-automata.hh.

template<typename... ValueSets>

using vcsn::detail::labelset_types = typedef labelset_types_impl<void, ValueSets...>

Definition at line 64 of file tupleset.hh.

template<typename LabelSet >

using vcsn::detail::law_t = typedef typename law_traits<LabelSet>::type

The smallest wordset that includes LabelSet.

Definition at line 255 of file labelset.hh.

template<typename Context >

using vcsn::detail::letterized_context = typedef context<letterized_t<labelset_t_of<Context>>, weightset_t_of<Context>>

Definition at line 114 of file labelset.hh.

template<Automaton Aut>

using vcsn::detail::letterized_ls = typedef letterized_traits<labelset_t_of<Aut>>

Definition at line 100 of file letterize.hh.

template<typename LabelSet >

using vcsn::detail::letterized_t = typedef typename letterized_traits<LabelSet>::labelset_t

Definition at line 93 of file labelset.hh.

template<Automaton Aut, size_t... Tapes>

using vcsn::detail::lifted_automaton_t = typedef mutable_automaton<typename lifter_t<context_t_of<Aut>, Tapes...>::context_t>

Definition at line 193 of file lift.hh.

template<typename ExpSet >

using vcsn::detail::lifted_expressionset_t = typedef expressionset<typename lifter_t<context_t_of<ExpSet>>::context_t>

Definition at line 277 of file lift.hh.

template<typename Ctx , size_t... Tapes>

using vcsn::detail::lifter_t = typedef lifter_impl<Ctx, detail::index_sequence<Tapes...>>

A traits to lift the Tapes of the labels to the weights.

Definition at line 188 of file lift.hh.

template<std::size_t S, std::size_t E>

using vcsn::detail::make_index_range_t = typedef typename make_index_range<S, E>::type

Definition at line 88 of file tuple.hh.

template<typename Ctx >

using vcsn::detail::nullableset_context_t = typedef context<nullableset_t<labelset_t_of<Ctx>>, weightset_t_of<Ctx>>

Definition at line 160 of file labelset.hh.

template<typename LabelSet >

using vcsn::detail::nullableset_t = typedef typename nullableset_traits<LabelSet>::type

The smallest nullableset that includes LabelSet.

Definition at line 144 of file labelset.hh.

template<typename LabelSet >

using vcsn::detail::one_t = typedef decltype(std::declval<LabelSet>().one())

Definition at line 36 of file labelset.hh.

template<Automaton Aut>

using vcsn::detail::origins_t_of = typedef typename origins_t_of_impl<Aut>::type

The type of the origins map for a partition automaton, or a transposed one.

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

template<Automaton Aut, wet_kind_t Kind = wet_kind<labelset_t_of<Aut>, weightset_t_of<Aut>>(), bool Lazy = false>

using vcsn::detail::polystate_automaton = typedef std::shared_ptr<polystate_automaton_impl<Aut, Kind, Lazy>>

A polystate automaton as a shared pointer.

Definition at line 156 of file polystate-automaton.hh.

template<typename T >

using vcsn::detail::power_mem_fn_t = typedef decltype(std::declval<T>() .power(std::declval<typename T::value_t>(), 0))

The signature of power.

Definition at line 38 of file weightset.hh.

template<bool Lazy, Automaton Aut, Automaton... Auts>

using vcsn::detail::product_automaton = typedef std::shared_ptr<detail::product_automaton_impl<Lazy, Aut, Auts...>>

A product automaton as a shared pointer.

Definition at line 603 of file conjunction.hh.

template<size_t Tape, typename Context >

using vcsn::detail::project_context = typedef context<project_labelset<Tape, labelset_t_of<Context>>, weightset_t_of<Context>>

The type of the resulting apparent context when keeping only tape Tape.

Definition at line 1368 of file tupleset.hh.

template<size_t Tape, typename LabelSet >

using vcsn::detail::project_labelset = typedef typename project_labelset_impl<Tape, LabelSet>::type

The type of the resulting apparent LabelSet when keeping only tape Tape.

Undefined when not applicable.

Definition at line 1341 of file tupleset.hh.

template<typename Context >

using vcsn::detail::proper_context = typedef context<proper_t<labelset_t_of<Context>>, weightset_t_of<Context>>

Definition at line 212 of file labelset.hh.

template<typename LabelSet >

using vcsn::detail::proper_t = typedef typename proper_traits<LabelSet>::type

The type of the corresponding proper LabelSet.

Definition at line 194 of file labelset.hh.

template<Automaton Aut>

using vcsn::detail::res_label_t_of = typedef typename res_label_t_of_impl<Aut>::type

Definition at line 37 of file compose.hh.

template<Automaton Aut>

using vcsn::detail::res_labelset_t_of = typedef typename res_labelset_t_of_impl<Aut>::type

Definition at line 36 of file compose.hh.

template<typename S1 , typename S2 >

using vcsn::detail::sequence_difference = typedef typename index_sequence_difference<typename S1::type, typename S2::type>::type

Definition at line 154 of file tuple.hh.

template<Automaton Aut>

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

Definition at line 206 of file synchronize.hh.

template<typename T >

using vcsn::detail::test_t = typedef decltype(std::declval<T>().size())

Definition at line 13 of file military-order.hh.

template<typename... Ts>

using vcsn::detail::void_t = typedef typename voider<Ts...>::type

Definition at line 25 of file type_traits.hh.

template<wet_kind_t Kind, typename Key , typename Value , typename Compare , typename Hash , typename KeyEqual >

using vcsn::detail::wet_impl = typedef std::conditional_t<Kind == wet_kind_t::bitset, wet_bitset, std::conditional_t<Kind == wet_kind_t::set, wet_set<Key, Compare>, std::conditional_t<Kind == wet_kind_t::map, wet_map<Key, Value, Compare>, std::conditional_t<Kind == wet_kind_t::unordered_map, wet_unordered_map<Key, Value, Hash, KeyEqual>, void> > > >

A weighted set type from its kind.

Definition at line 837 of file wet.hh.

template<typename Ctx >

using vcsn::detail::word_context_t = typedef context<law_t<labelset_t_of<Ctx>>, weightset_t_of<Ctx>>

Definition at line 271 of file labelset.hh.

template<typename Ctx >

using vcsn::detail::word_polynomialset_t = typedef polynomialset<word_context_t<Ctx>>

Definition at line 15 of file word-polynomialset.hh.

Function Documentation

template<Automaton Aut>

fresh_automaton_t_of<Aut> vcsn::detail::absval ( const Aut & aut )

Copy of aut, with absolute values.

Templated to avoid useless instantiations.

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

References vcsn::copy(), vcsn::res, and transitions().

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

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::all_in	(	const Aut &	aut,
		state_t_of< Aut >	s
	)

Indexes of transitions entering state s.

Invalidated by del_transition() and del_state().

Definition at line 114 of file automaton.hh.

Referenced by vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_impl_(), in(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover_(), vcsn::rat::zpc_visitor< Aut, ExpSet >::operator()(), vcsn::detail::epsilon_remover_distance< Aut, has_one >::operator()(), vcsn::paths_ibfs(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::remover_on(), vcsn::standard_here(), vcsn::are_isomorphicer< Aut1, Aut2 >::state_to_class(), vcsn::detail::naive_profiler< Aut >::update(), and vcsn::detail::delgado_profiler< Aut >::update().

template<Automaton Aut, typename Pred >

auto vcsn::detail::all_in	(	const Aut &	aut,
		state_t_of< Aut >	s,
		Pred	pred
	)

Indexes of transitions entering state s that validate the predicate.

Invalidated by del_transition() and del_state().

Definition at line 124 of file automaton.hh.

References vcsn::make_container_filter_range().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::all_out	(	const Aut &	aut,
		state_t_of< Aut >	s
	)

Indexes of transitions leaving state s.

Invalidated by del_transition() and del_state().

Definition at line 65 of file automaton.hh.

Referenced by vcsn::accessible_states(), vcsn::detail::lazy_tuple_automaton< product_automaton_impl< Lazy, Aut, Auts... >, false, Lazy, Aut, Auts... >::all_out(), vcsn::detail::derived_term_automaton_impl< ExpSet >::all_out(), vcsn::detail::epsilon_remover< Aut, has_one >::build_heap_(), vcsn::detail::transition_map< automaton_t, weightset_t_of< automaton_t >, true, true >::build_map_(), vcsn::detail::cycle_identity_impl< Aut >::check(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_impl_(), vcsn::evaluate(), vcsn::detail::bounded_lag_checker< Aut >::has_bounded_lag(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover_(), vcsn::is_complete(), vcsn::is_deterministic(), vcsn::are_isomorphicer< Aut1, Aut2 >::is_isomorphism_valid_throwing(), vcsn::is_partial_identity(), vcsn::detail::letterizer< AutIn, AutOut >::letterize(), vcsn::detail::lightest_impl< Aut >::lightest_(), vcsn::detail::standard_operations< Aut >::lweight_here(), vcsn::detail::minimizer< Aut, signature_tag >::minimizer(), vcsn::detail::evaluator< Aut >::operator()(), vcsn::detail::quotienter< Aut >::operator()(), vcsn::detail::dijkstra_impl< Aut, ValueSet, Mul >::operator()(), vcsn::detail::a_star_impl< Aut >::operator()(), vcsn::detail::epsilon_remover_distance< Aut, has_one >::operator()(), out(), outin(), vcsn::detail::daut_impl< Aut >::print_transitions_(), vcsn::detail::dot_impl< Aut >::print_transitions_(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::remover_on(), vcsn::detail::enumerater< Aut >::shortest_(), vcsn::detail::minimizer< Aut, weighted_tag >::signature(), vcsn::ss_shortest_distance(), vcsn::standard_here(), vcsn::are_isomorphicer< Aut1, Aut2 >::state_to_class(), vcsn::detail::naive_profiler< Aut >::update(), vcsn::detail::delgado_profiler< Aut >::update(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::update_profile_(), vcsn::detail::epsilon_remover< Aut, has_one >::update_profile_(), vcsn::rat::zpc_visitor< Aut, ExpSet >::VCSN_RAT_VISIT(), vcsn::rat::standard_visitor< Aut, ExpSet >::VCSN_RAT_VISIT(), and vcsn::detail::sorter< Aut >::visit_successors_of_().

template<Automaton Aut, typename Pred >

auto vcsn::detail::all_out	(	const Aut &	aut,
		state_t_of< Aut >	s,
		Pred	pred
	)

Indexes of transitions leaving state s that validate the predicate.

Invalidated by del_transition() and del_state().

Definition at line 75 of file automaton.hh.

References vcsn::make_container_filter_range().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::all_transitions ( const Aut & aut )

All the transition indexes between all states (including pre and post).

Definition at line 212 of file automaton.hh.

Referenced by vcsn::add_here(), vcsn::all_distances(), bellman_ford_impl(), vcsn::create_states_and_trans_(), vcsn::are_isomorphicer< Aut1, Aut2 >::fill_nouts_(), vcsn::are_isomorphicer< Aut1, Aut2 >::is_sequential_filling(), vcsn::detail::copier< AutIn, AutOut >::operator()(), vcsn::partial_identity(), vcsn::push_weights(), and vcsn::to_spontaneous().

template<Automaton Aut, typename Pred >

auto vcsn::detail::all_transitions	(	const Aut &	aut,
		Pred	pred
	)

All the transition indexes between all states (including pre and post), that validate pred.

Definition at line 220 of file automaton.hh.

References vcsn::make_container_filter_range().

Here is the call graph for this function:

template<typename Range , typename Predicate >

bool vcsn::detail::any_of	(	const Range &	r,
		Predicate	p
	)

Definition at line 16 of file algorithm.hh.

References any_of().

Referenced by vcsn::rat::star_normal_form_visitor< ExpSet >::box_of().

Here is the call graph for this function:

template<typename Range >

bool vcsn::detail::any_of ( const Range & r )

Definition at line 24 of file algorithm.hh.

Referenced by any_of().

template<typename Fun , typename... Args>

auto vcsn::detail::apply	(	Fun	f,
		const std::tuple< Args... > &	args
	)		-> decltype(apply_impl_(f, args, make_index_sequence<sizeof...(Args)>()))

Unpack a tuple, and pass its content as argument to a funtion.

Definition at line 196 of file tuple.hh.

References apply_impl_().

Here is the call graph for this function:

template<typename... Funs, typename... Args>

auto vcsn::detail::apply	(	const std::tuple< Funs... > &	funs,
		const std::tuple< Args... > &	args
	)

Apply a tuple of functions on a tuple of arguments, return the tuple of results.

Definition at line 219 of file tuple.hh.

References apply_impl_().

Here is the call graph for this function:

template<typename Fun , typename... Objs, typename... Args>

auto vcsn::detail::apply	(	Fun	fun,
		const std::tuple< Objs... > &	objs,
		const std::tuple< Args... > &	args
	)

Apply a tuple of member functions on a tuple of arguments, return the tuple of results.

Definition at line 242 of file tuple.hh.

References apply_impl_().

Here is the call graph for this function:

template<typename Fun , typename... Args, size_t... I>

auto vcsn::detail::apply_impl_	(	Fun	f,
		const std::tuple< Args... > &	args,
		index_sequence< I... >
	)		-> decltype(f(std::get<I>(args)...))

Definition at line 205 of file tuple.hh.

Referenced by apply().

template<typename... Funs, typename... Args, size_t... I>

auto vcsn::detail::apply_impl_	(	const std::tuple< Funs... > &	funs,
		const std::tuple< Args... > &	args,
		index_sequence< I... >
	)

Apply a tuple of functions on a tuple of arguments, return the tuple of results.

Definition at line 230 of file tuple.hh.

template<typename Fun , typename... Objs, typename... Args, size_t... I>

auto vcsn::detail::apply_impl_	(	Fun	fun,
		const std::tuple< Objs... > &	objs,
		const std::tuple< Args... > &	args,
		index_sequence< I... >
	)

Definition at line 253 of file tuple.hh.

template<typename Container >

Container::value_type vcsn::detail::back ( const Container & container )

The last member of this Container.

Should be specialized for containers with random access.

Definition at line 37 of file algorithm.hh.

References vcsn::res.

Referenced by vcsn::rat::parser::parse().

template<Automaton Aut>

boost::optional<std::vector<transition_t_of<Aut> > > vcsn::detail::bellman_ford_impl	(	const Aut &	aut,
		state_t_of< Aut >	source
	)

Bellman-Ford implementation of lightest automaton.

Function applying Bellman-Ford algorithm to the automaton given as parameter. Return the array of lightest 'in' transition of each state.

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

References all_transitions(), vcsn::res, vcsn::rat::size(), states_size(), and transitions().

Referenced by vcsn::has_lightening_cycle(), and vcsn::lightest_path().

Here is the call graph for this function:

template<Automaton Aut, Automaton... Auts>

auto vcsn::detail::conjunction	(	const Aut &	a,
		const Auts &...	as
	)

Build the (accessible part of the) conjunction.

Definition at line 622 of file conjunction.hh.

References insplit(), meet_automata(), and vcsn::res.

Referenced by vcsn::detail::is_ambiguous_impl< Aut >::is_ambiguous_impl().

Here is the call graph for this function:

template<Automaton Aut, Automaton... Auts>

auto vcsn::detail::conjunction_lazy	(	const Aut &	a,
		const Auts &...	as
	)

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

Definition at line 633 of file conjunction.hh.

References insplit(), meet_automata(), and vcsn::res.

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

Here is the call graph for this function:

template<typename LabelSet >

LabelSet::letters_t vcsn::detail::conv_label_class_	(	const LabelSet &	ls,
		std::istream &	i
	)

Read a set of letters (hence, guaranteed in order, and unique).

Definition at line 442 of file labelset.hh.

References vcsn::res.

Referenced by conv_label_class_(), vcsn::detail::tupleset_impl< ValueSets >::convs(), and vcsn::detail::genset_labelset< GenSet >::convs_().

template<typename LabelSet , typename Fun >

void vcsn::detail::conv_label_class_	(	const LabelSet &	ls,
		std::istream &	i,
		Fun	fun
	)

Read and process a class of letters.

Stream i is after the '[', read up to the closing ']', excluded. Apply fun to all the letters. Take negation into account. Classes can never be empty. For instance "[a-d0-9_]", or "[^a-fz], or "[^]", but not "[]".

Beware that symbols are processed as they are discovered, so there is no guarantee that symbols will be processed only once: [aaa] will process a three times. If this is undesirable, use the overload below that returns a set.

Precondition: i does not start with ']' or '-'.

Definition at line 382 of file labelset.hh.

References conv_label_class_(), vcsn::require(), and vcsn::set_difference().

Here is the call graph for this function:

template<typename Fun >

void vcsn::detail::cross ( Fun f )

Variadic Cartesian product of containers.

Based on http://stackoverflow.com/questions/13813007/

Beware of name conflicts with vcsn/misc/cross.

Definition at line 273 of file tuple.hh.

Referenced by cross(), cross_tuple_(), and vcsn::detail::polynomialset_impl< Context, Kind >::tuple().

template<typename Fun , typename Cont , typename... Conts>

void vcsn::detail::cross	(	Fun	f,
		const Cont &	head,
		const Conts &...	tails
	)

Definition at line 281 of file tuple.hh.

References cross().

Here is the call graph for this function:

template<typename Fun , typename... Ts>

void vcsn::detail::cross_tuple	(	Fun	f,
		const std::tuple< Ts... > &	ts
	)

Definition at line 301 of file tuple.hh.

References cross_tuple_().

Referenced by vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::add_add_transitions(), vcsn::detail::compose_automaton_impl< Lazy, Lhs, Rhs >::add_compose_transitions(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::add_conjunction_transitions(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::add_ldivide_transitions(), and vcsn::rat::expansionset< ExpSet >::tuple_impl< Expansions >::tuple().

Here is the call graph for this function:

template<typename Fun , typename... Ts, size_t... I>

void vcsn::detail::cross_tuple_	(	Fun	f,
		const std::tuple< Ts... > &	ts,
		index_sequence< I... >
	)

Definition at line 292 of file tuple.hh.

References cross().

Referenced by cross_tuple().

Here is the call graph for this function:

static int vcsn::detail::debug_level ( )

inlinestatic

Debug level set in the user's environment.

Definition at line 11 of file debug-level.hh.

References lexical_cast().

Referenced by vcsn::rat::driver::parse().

Here is the call graph for this function:

template<Automaton Aut>

void vcsn::detail::del_transition	(	const Aut &	aut,
		state_t_of< Aut >	s,
		state_t_of< Aut >	d
	)

Remove all the transitions between s and d.

Definition at line 198 of file automaton.hh.

References make_vector(), and outin().

Here is the call graph for this function:

template<Automaton... Aut, typename Operation >

auto vcsn::detail::dispatch_tags	(	std::string	algo,
		Operation	op,
		Aut &&...	auts
	)

Dispatch an operation between automata depending on their nature.

Definition at line 46 of file tags.hh.

References vcsn::all(), vcsn::is_deterministic(), vcsn::is_standard(), vcsn::require(), vcsn::res, and vcsn::str_escape().

Referenced by vcsn::dyn::add(), vcsn::dyn::multiply(), vcsn::dyn::detail::multiply_repeated(), and vcsn::dyn::star().

Here is the call graph for this function:

template<typename Container , typename Predicate >

void vcsn::detail::erase_if	(	Container &	c,
		const Predicate &	p
	)

Definition at line 51 of file algorithm.hh.

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

template<Automaton Aut>

auto vcsn::detail::fado_impl_	(	const Aut &	aut,
		std::ostream &	out
	)		-> std::enable_if_t<has_fado_t<Aut>

Definition at line 46 of file print.hh.

template<Automaton Aut>

ATTRIBUTE_NORETURN auto vcsn::detail::fado_impl_	(	const Aut &	,
		std::ostream &
	)		-> std::enable_if_t<!has_fado_t<Aut>

Definition at line 55 of file print.hh.

template<Automaton Aut>

auto vcsn::detail::final_transitions ( const Aut & aut ) -> decltype(aut->all_in(aut->post()))

Indexes of transitions from (visible) final states.

Also include the weird case of a transition from pre to post. This is used when calling eliminate_state repeatedly.

Definition at line 176 of file automaton.hh.

Referenced by vcsn::complement_here(), vcsn::conjugate(), vcsn::detail::determinized_automaton_impl< Aut, Kind, Lazy >::determinized_automaton_impl(), vcsn::rat::standard_visitor< Aut, ExpSet >::finals(), vcsn::detail::printer< Aut >::finals_(), vcsn::detail::left_reductioner< Aut >::linear_representation(), vcsn::multiply_here(), vcsn::detail::dot_impl< Aut >::print_states_(), vcsn::detail::efsmer< Aut >::print_transitions_(), vcsn::star_here(), vcsn::rat::standard_visitor< Aut, ExpSet >::VCSN_RAT_VISIT(), and vcsn::detail::universal_impl< Aut >::work_().

template<typename Fun , typename... Ts>

void vcsn::detail::for_	(	const std::tuple< Ts... > &	ts,
		Fun	f
	)

Definition at line 158 of file tuple.hh.

template<typename Fun , typename... Ts, size_t... I>

void vcsn::detail::for_	(	Fun	f,
		const std::tuple< Ts... > &	ts,
		index_sequence< I... >
	)

Definition at line 165 of file tuple.hh.

References void.

template<typename Container >

Container::value_type vcsn::detail::front ( const Container & container )

The first member of this Container.

Definition at line 68 of file algorithm.hh.

Referenced by vcsn::add_here(), vcsn::detail::polynomialset_impl< Context, Kind >::add_ldivide_here(), vcsn::de_bruijn(), vcsn::detail::standard_operations< Aut >::lweight_here(), vcsn::rat::driver::make_expression(), vcsn::detail::trie_builder< Context, Dir >::next_(), vcsn::detail::polynomialset_impl< Context, Kind >::norm_< WeightSet, Dummy >::operator()(), vcsn::detail::polynomialset_impl< Context, Kind >::norm_< z, Dummy >::operator()(), vcsn::detail::polynomialset_impl< Context, Kind >::norm_< polynomialset< Ctx, Knd >, Dummy >::operator()(), vcsn::detail::polynomialset_impl< Context, Kind >::print_with_classes_(), vcsn::star_here(), and vcsn::detail::universal_impl< Aut >::work_().

ATTRIBUTE_PURE unsigned int vcsn::detail::gcd	(	unsigned int	a,
		unsigned int	b
	)

inline

Greatest common divisor.

Definition at line 13 of file math.hh.

References vcsn::require().

Referenced by lcm(), vcsn::detail::z_impl::lgcd(), and vcsn::detail::q_impl::value_t::reduce().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::grail_impl_	(	const Aut &	aut,
		std::ostream &	out
	)		-> std::enable_if_t<has_grail_t<Aut>

Definition at line 64 of file print.hh.

template<Automaton Aut>

ATTRIBUTE_NORETURN auto vcsn::detail::grail_impl_	(	const Aut &	,
		std::ostream &
	)		-> std::enable_if_t<!has_grail_t<Aut>

Definition at line 73 of file print.hh.

template<typename T >

auto vcsn::detail::hash_value ( const T & v ) -> decltype(std::hash<T>

Following the naming convention of Boost.

Use SFINAE to avoid being too eager.

Definition at line 30 of file functional.hh.

return vcsn::detail::hasher ( v )

Referenced by vcsn::rat::expressionset_impl< Context >::hash(), std::hash< unordered_set< Key, Hash, KeyEqual, Alloc > >::operator()(), and std::hash< vcsn::symbol >::operator()().

template<Automaton Aut>

auto vcsn::detail::in	(	const Aut &	aut,
		state_t_of< Aut >	s
	)

Indexes of visible transitions arriving to state s.

Invalidated by del_transition() and del_state().

Definition at line 133 of file automaton.hh.

References all_in().

Referenced by vcsn::detail::epsilon_remover< Aut, has_one >::build_heap_(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::build_heap_(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_impl_(), vcsn::detail::epsilon_remover_distance< Aut, has_one >::epsilon_remover_distance(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::epsilon_remover_separate(), vcsn::get_file_contents(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover_(), vcsn::is_standard(), vcsn::make_copier(), vcsn::minimize(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::operator()(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::remover_on(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::state_has_spontaneous_in(), vcsn::detail::naive_profiler< Aut >::update(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::update_profile_(), vcsn::detail::epsilon_remover< Aut, has_one >::update_profile_(), and vcsn::rat::thompson_visitor< Aut, ExpSet >::VCSN_RAT_VISIT().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::in	(	const Aut &	aut,
		state_t_of< Aut >	s,
		label_t_of< Aut >	l
	)

Indexes of visible transitions arriving to state s on label l.

Invalidated by del_transition() and del_state().

Definition at line 146 of file automaton.hh.

References all_in().

Here is the call graph for this function:

template<typename Iterator , typename Pred , typename Less >

boost::iterator_range<Iterator> vcsn::detail::initial_sorted_range	(	Iterator	begin,
		Iterator	end,
		Pred	pred,
		Less	less
	)

The longest initial range of elements matching the predicate.

Definition at line 80 of file algorithm.hh.

Referenced by vcsn::rat::printer< ExpSet >::letter_range().

template<Automaton Aut>

auto vcsn::detail::initial_transitions ( const Aut & aut ) -> decltype(aut->all_out(aut->pre()))

Indexes of transitions to (visible) initial states.

Also include the weird case of a transition from pre to post. This is used when calling eliminate_state repeatedly.

Definition at line 165 of file automaton.hh.

Referenced by vcsn::add_here(), vcsn::conjugate(), vcsn::evaluate(), vcsn::detail::printer< Aut >::initials_(), vcsn::is_deterministic(), vcsn::is_standard(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::ldivide_here(), vcsn::detail::left_reductioner< Aut >::linear_representation(), vcsn::detail::standard_operations< Aut >::lweight_here(), vcsn::multiply_here(), vcsn::detail::dot_impl< Aut >::print_states_(), vcsn::detail::efsmer< Aut >::print_transitions_(), vcsn::standard_here(), vcsn::star_here(), and vcsn::detail::universal_impl< Aut >::work_().

template<Automaton Aut>

auto vcsn::detail::insplit	(	Aut	aut,
		bool	= `false`
	)		-> std::enable_if_t<!labelset_t_of< Aut >::has_one(), Aut >

Insplit an automaton with possible spontaneous transitions.

Insplit an automaton without spontaneous transitions.

Identity.

Definition at line 266 of file insplit.hh.

References make_insplit_automaton(), and vcsn::res.

Referenced by conjunction(), conjunction_lazy(), vcsn::ldivide(), and vcsn::make_compose_automaton().

Here is the call graph for this function:

template<typename C >

ATTRIBUTE_NORETURN void vcsn::detail::invalid_argument	(	const std::string &	kind,
		const std::string &	key,
		const C &	map
	)

Definition at line 20 of file getargs.hh.

References vcsn::copy().

Referenced by vcsn::getarg< Value >::operator[]().

Here is the call graph for this function:

template<typename Integer >

auto vcsn::detail::irange ( Integer last )

Generate an integer range.

Benches in -O3 show no difference with a traditional for loop.

Definition at line 11 of file irange.hh.

Referenced by vcsn::random_automaton_deterministic().

template<Automaton Aut>

std::enable_if_t<!is_letterized_t<labelset_t_of<Aut> >{}, bool> vcsn::detail::is_letterized ( const Aut & aut )

Definition at line 161 of file letterize.hh.

References transitions().

Referenced by vcsn::derivation(), vcsn::detail::tupleset_impl< ValueSets >::generators_(), vcsn::is_letterized(), vcsn::nullableset< LabelSet >::is_letterized(), vcsn::detail::tupleset_impl< ValueSets >::is_letterized_(), and vcsn::detail::letterized_traits< tupleset< LabelSets... > >::is_letterized_().

Here is the call graph for this function:

template<Automaton Aut>

std::enable_if_t<is_letterized_t<labelset_t_of<Aut> >{}, bool> vcsn::detail::is_letterized ( const Aut & )

Definition at line 178 of file letterize.hh.

template<Automaton Aut>

std::enable_if_t<labelset_t_of<Aut>::has_one(), bool> vcsn::detail::is_proper_ ( const Aut & aut )

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

References transitions().

Referenced by vcsn::is_proper().

Here is the call graph for this function:

template<Automaton Aut>

constexpr std::enable_if_t<!labelset_t_of<Aut>::has_one(), bool> vcsn::detail::is_proper_ ( const Aut & )

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

template<Automaton Aut>

bool vcsn::detail::is_properable ( Aut && aut )

Whether proper_here(aut) succeeds.

Destroys aut.

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

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

template<typename Container , typename Compare >

bool vcsn::detail::is_sorted_forward	(	const Container &	container,
		Compare	comp
	)

Same as std::is_sorted, but works with an input iterator, not just a forward iterator.

See http://stackoverflow.com/questions/25906893.

Definition at line 101 of file algorithm.hh.

Referenced by vcsn::is_out_sorted().

template<Automaton Aut>

bool vcsn::detail::is_special	(	const Aut &	aut,
		transition_t_of< Aut >	t
	)

Whether this transition is from pre or to post.

Definition at line 227 of file automaton.hh.

Referenced by vcsn::nullableset< LabelSet >::is_special(), vcsn::detail::tupleset_impl< ValueSets >::is_special_(), vcsn::detail::is_special_t< Aut >::operator()(), and vcsn::detail::tupleset_impl< ValueSets >::print_().

template<Automaton Aut>

bool vcsn::detail::is_synchronized ( const Aut & aut )

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

template<typename V1 , typename V2 >

join_impl<V1, V2>::type vcsn::detail::join_	(	V1	v1,
		V2	v2,
		int
	)

Dealing with commutativity: two implementations of join_: forward and reversed, ordered by preference by the use of "0 prefers int to long" disambiguation rule.

Definition at line 26 of file join.hh.

References vcsn::join().

Referenced by vcsn::join().

Here is the call graph for this function:

template<typename V1 , typename V2 >

join_impl<V1, V2>::type vcsn::detail::join_	(	V2	v2,
		V1	v1,
		long
	)

Definition at line 33 of file join.hh.

References vcsn::join().

Here is the call graph for this function:

template<Automaton... Auts>

auto vcsn::detail::join_automata ( Auts &&... auts ) -> decltype(pass(auts->null_state()...), make_mutable_automaton(join(auts->context()...)))

An automaton whose type is the join between those of auts.

Definition at line 13 of file join-automata.hh.

References vcsn::join(), and vcsn::make_mutable_automaton().

Referenced by vcsn::add(), vcsn::infiltrate(), vcsn::ldivide(), make_join_automaton(), and vcsn::shuffle().

Here is the call graph for this function:

static labelset_t::value_t vcsn::detail::kept_label ( const in_label_t & l )

static

Label in the output.

Definition at line 159 of file lift.hh.

References kept_label_().

Here is the call graph for this function:

template<size_t... I>

static labelset_t::value_t vcsn::detail::kept_label_	(	const in_label_t &	l,
		seq< I... >
	)

static

Definition at line 166 of file lift.hh.

Referenced by kept_label().

template<typename LabelSet >

auto vcsn::detail::label_one ( const LabelSet & ls ) -> typename LabelSet::value_t

Enjoy type inference.

Definition at line 55 of file labelset.hh.

Referenced by vcsn::detail::tuple_automata_impl< Aut, Auts >::add_tape_transitions_(), vcsn::rat::expressionset_impl< Context >::tuple_of_label< Dummy >::as_label_(), and vcsn::rat::expansionset< expressionset_t >::ldivide().

ATTRIBUTE_PURE unsigned int vcsn::detail::lcm	(	unsigned int	a,
		unsigned int	b
	)

inline

Lowest common multiple.

Definition at line 28 of file math.hh.

References gcd().

Referenced by vcsn::detail::q_impl::add(), and vcsn::detail::q_impl::sub().

Here is the call graph for this function:

template<typename ExpSet >

auto vcsn::detail::letter_class_impl	(	const ExpSet &	,
		const letter_class_t &	,
		bool	,
		std::false_type	,
		std::true_type
	)		-> typename ExpSet::value_t

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

Referenced by vcsn::to_expression().

template<typename ExpSet >

auto vcsn::detail::letter_class_impl	(	const ExpSet &	rs,
		const letter_class_t &	chars,
		bool	accept,
		std::false_type	,
		std::false_type
	)		-> typename ExpSet::value_t

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

References rs.

template<typename ExpSet >

auto vcsn::detail::letter_class_impl	(	const ExpSet &	rs,
		const letter_class_t &	,
		bool	,
		std::true_type	,
		std::false_type
	)		-> typename ExpSet::value_t

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

References rs.

template<Automaton Aut>

std::enable_if_t<!is_letterized_t<labelset_t_of<Aut> >{}, mutable_automaton<letterized_context<context_t_of<Aut> > > > vcsn::detail::letterize ( const Aut & aut )

Letterize an automaton whose type is not letterized already.

Definition at line 106 of file letterize.hh.

References make_letterized().

Referenced by vcsn::letterize().

Here is the call graph for this function:

template<Automaton Aut>

std::enable_if_t<is_letterized_t<labelset_t_of<Aut> >{}, const Aut&> vcsn::detail::letterize ( const Aut & aut )

Letterize an automaton whose type is letterized: do nothing.

Definition at line 118 of file letterize.hh.

template<typename T >

T vcsn::detail::lexical_cast ( const std::string & str )

String to templated type T conversion.

This lexical cast is similar to boost::lexical_cast.

Definition at line 79 of file cast.hh.

References vcsn::res, vcsn::str_escape(), and VCSN_REQUIRE.

Referenced by debug_level(), and vcsn::detail::random_expression_impl< ExpressionSet, RandomGenerator >::parse_param_().

Here is the call graph for this function:

template<typename LabelSet , typename WeightSet , size_t... Tapes>

lifter_t<context<LabelSet, WeightSet>, Tapes...>::context_t vcsn::detail::lift_context ( const context< LabelSet, WeightSet > & ctx )

lift(ctx) -> ctx

Definition at line 198 of file lift.hh.

template<typename Context >

lifted_expressionset_t<expressionset<Context> > vcsn::detail::lift_expressionset	(	const expressionset< Context > &	rs,
		boost::optional< vcsn::rat::identities >	ids = `{}`
	)

lift(expressionset) -> expressionset

Definition at line 282 of file lift.hh.

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

template<Automaton Aut, typename Tag >

std::vector<transition_t_of<Aut> > vcsn::detail::lightest_path_tag	(	const Aut &	aut,
		state_t_of< Aut >	src,
		state_t_of< Aut >	dst
	)

Tag-based dispatch on implementation.

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

References vcsn::lightest_path().

Here is the call graph for this function:

template<Automaton Aut>

delay_automaton<Aut> vcsn::detail::make_delay_automaton ( const Aut & aut )

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

template<Automaton Aut, typename ValueSet , typename Mul >

auto vcsn::detail::make_dijkstra_impl	(	const Aut &	aut,
		const ValueSet &	vs,
		Mul	mul
	)

Definition at line 129 of file dijkstra.hh.

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

template<typename LabelSet , typename WeightSet >

free_context<context<LabelSet, WeightSet> > vcsn::detail::make_free_context ( const context< LabelSet, WeightSet > & c )

The free context for c.

Definition at line 236 of file labelset.hh.

References vcsn::context< LabelSet, WeightSet >::labelset(), make_letterized(), make_proper(), and vcsn::context< LabelSet, WeightSet >::weightset().

Referenced by make_trie_builder().

Here is the call graph for this function:

template<typename... Ts>

auto vcsn::detail::make_gcc_tuple ( Ts &&... ts ) -> decltype(reverse_tuple(std::make_tuple(std::forward<Ts>(ts)...)))

Same as make_tuple, unless the evaluation of arguments if right-to-left, in which case reverse the result.

Definition at line 342 of file tuple.hh.

References reverse_tuple().

Referenced by vcsn::detail::tupleset_impl< ValueSets >::conv_(), vcsn::detail::tupleset_impl< ValueSets >::get_letter_(), and vcsn::detail::tupleset_impl< ValueSets >::make_().

Here is the call graph for this function:

template<Automaton Aut>

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

Build an insplit automaton from an automaton.

Definition at line 256 of file insplit.hh.

Referenced by insplit().

template<Automaton... Auts>

auto vcsn::detail::make_join_automaton	(	deterministic_tag	,
		Auts &&...	auts
	)		-> decltype(join_automata(std::forward<Auts>(auts)...))

Make an empty automaton which is a supertype of others.

Definition at line 101 of file tags.hh.

References join_automata().

Here is the call graph for this function:

template<Automaton... Auts>

auto vcsn::detail::make_join_automaton	(	general_tag	,
		Auts &&...	auts
	)		-> decltype(nullable_join_automata(std::forward<Auts>(auts)...))

Make an empty automaton which is a supertype of others, and with a nullable labelset.

Definition at line 112 of file tags.hh.

References nullable_join_automata().

Here is the call graph for this function:

template<Automaton... Auts>

auto vcsn::detail::make_join_automaton	(	standard_tag	,
		Auts &&...	auts
	)		-> decltype(join_automata(std::forward<Auts>(auts)...))

Make an empty automaton which is a supertype of others.

Definition at line 122 of file tags.hh.

References join_automata().

Here is the call graph for this function:

template<typename LabelSet >

letterized_t<LabelSet> vcsn::detail::make_letterized ( const LabelSet & ls )

Definition at line 101 of file labelset.hh.

References vcsn::detail::letterized_traits< LabelSet >::labelset().

Referenced by vcsn::detail::letterized_traits< tupleset< LabelSets... > >::labelset_(), letterize(), make_free_context(), and make_letterized_context().

Here is the call graph for this function:

template<typename LabelSet , typename WeightSet >

letterized_context<context<LabelSet, WeightSet> > vcsn::detail::make_letterized_context ( const context< LabelSet, WeightSet > & c )

The letterized context for c.

Definition at line 119 of file labelset.hh.

References vcsn::context< LabelSet, WeightSet >::labelset(), make_letterized(), and vcsn::context< LabelSet, WeightSet >::weightset().

Here is the call graph for this function:

template<typename LabelSet >

nullableset_t<LabelSet> vcsn::detail::make_nullableset ( const LabelSet & ls )

inline

The nullableset of a labelset.

Definition at line 149 of file labelset.hh.

Referenced by make_nullableset_context().

template<typename LabelSet , typename WeightSet >

nullableset_context_t<context<LabelSet, WeightSet> > vcsn::detail::make_nullableset_context ( const context< LabelSet, WeightSet > & ctx )

inline

The nullableset context of a context.

Definition at line 165 of file labelset.hh.

References vcsn::context< LabelSet, WeightSet >::labelset(), make_nullableset(), and vcsn::context< LabelSet, WeightSet >::weightset().

Referenced by vcsn::make_nullable_automaton(), nullable_join_context(), vcsn::dyn::thompson(), and vcsn::dyn::zpc().

Here is the call graph for this function:

template<typename Context , wet_kind_t Kind = detail::wet_kind<labelset_t_of<Context>, weightset_t_of<Context>>()>

polynomialset<Context, Kind> vcsn::detail::make_polynomialset ( const Context & context )

Definition at line 1536 of file polynomialset.hh.

Referenced by vcsn::join_weightset_polynomialset(), vcsn::minimize(), project(), and vcsn::detail::polynomialset_impl< Context, Kind >::project().

template<Automaton Aut, wet_kind_t Kind = wet_kind<labelset_t_of<Aut>, weightset_t_of<Aut>>(), bool Lazy = false>

auto vcsn::detail::make_polystate_automaton ( const Aut & aut )

Definition at line 163 of file polystate-automaton.hh.

template<bool Lazy, Automaton Aut, Automaton... Auts>

auto vcsn::detail::make_product_automaton	(	Aut	aut,
		const Auts &...	auts
	)		-> product_automaton<Lazy, Aut, Auts...>

Definition at line 607 of file conjunction.hh.

template<typename LabelSet >

proper_t<LabelSet> vcsn::detail::make_proper ( const LabelSet & ls )

The corresponding proper LabelSet.

Definition at line 199 of file labelset.hh.

References vcsn::detail::proper_traits< LabelSet >::value().

Referenced by make_free_context(), and make_proper_context().

Here is the call graph for this function:

template<typename LabelSet , typename WeightSet >

auto vcsn::detail::make_proper_context ( const context< LabelSet, WeightSet > & ctx ) -> proper_context<context<LabelSet, WeightSet>>

From a context, its non-nullable context.

Definition at line 217 of file labelset.hh.

References ctx, and make_proper().

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

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::make_properer	(	Aut	aut,
		bool	prune = `true`,
		const std::string &	algo = `"auto"`
	)

Definition at line 210 of file proper.hh.

Referenced by vcsn::proper(), and vcsn::proper_here().

template<typename Range >

std::queue<typename Range::value_type> vcsn::detail::make_queue ( const Range & range )

The content of cont as a queue.

Definition at line 16 of file queue.hh.

References vcsn::res.

Referenced by vcsn::paths_ibfs().

template<typename ExpressionSet , typename RandomGenerator = std::mt19937>

random_expression_impl<ExpressionSet, RandomGenerator> vcsn::detail::make_random_expression_impl	(	const ExpressionSet &	rs,
		const std::string &	param,
		RandomGenerator &	gen = `make_random_engine()`
	)

Convenience constructor.

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

References rs.

Referenced by vcsn::random_expression(), and vcsn::random_expression_string().

template<Automaton Aut, typename Profiler >

state_eliminator<Aut, Profiler> vcsn::detail::make_state_eliminator	(	Aut &	a,
		Profiler &	profiler
	)

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

Referenced by vcsn::eliminate_state_here(), and vcsn::to_expression().

template<direction Dir, typename PolynomialSet >

trie_builder<free_context<context_t_of<PolynomialSet> >, Dir> vcsn::detail::make_trie_builder ( const PolynomialSet & ps )

Instantiate a trie-builder for this type of polynomialset.

Definition at line 201 of file trie.hh.

References make_free_context().

Here is the call graph for this function:

template<typename... ValueSets>

tupleset<ValueSets...> vcsn::detail::make_tupleset ( const ValueSets &... vss )

Definition at line 1152 of file tupleset.hh.

Referenced by vcsn::tuple_context().

template<typename Cont >

std::vector<typename Cont::value_type> vcsn::detail::make_vector ( const Cont & cont )

The content of cont as a vector.

Definition at line 20 of file vector.hh.

Referenced by del_transition(), vcsn::double_ring(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_impl_(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover_(), vcsn::ladybird(), vcsn::levenshtein(), vcsn::minimize(), vcsn::multiply_here(), vcsn::quotkbaseb(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::remover_on(), and vcsn::rat::standard_visitor< Aut, ExpSet >::VCSN_RAT_VISIT().

template<typename LabelSet , typename WeightSet >

word_context_t<context<LabelSet, WeightSet> > vcsn::detail::make_word_context ( const context< LabelSet, WeightSet > & ctx )

inline

The wordset context of a context.

Definition at line 276 of file labelset.hh.

References vcsn::context< LabelSet, WeightSet >::labelset(), make_wordset(), and vcsn::context< LabelSet, WeightSet >::weightset().

Referenced by make_word_polynomialset().

Here is the call graph for this function:

template<typename Ctx >

auto vcsn::detail::make_word_polynomialset ( const Ctx & ctx ) -> word_polynomialset_t<Ctx>

inline

The polynomialset of words of a labelset (not necessarily on words itself).

Definition at line 21 of file word-polynomialset.hh.

References ctx, and make_word_context().

Referenced by vcsn::detail::trie_builder< Context, Dir >::add_monomials(), vcsn::dyn::detail::cotrie_stream(), vcsn::lightest(), vcsn::dyn::lightest(), vcsn::detail::yen_impl< Aut, ValueSet, Mul, GetValue >::operator()(), vcsn::path_monomial(), vcsn::dyn::shortest(), and vcsn::dyn::detail::trie_stream().

Here is the call graph for this function:

template<typename LabelSet >

law_t<LabelSet> vcsn::detail::make_wordset ( const LabelSet & ls )

inline

The wordset of a labelset.

Definition at line 260 of file labelset.hh.

Referenced by vcsn::detail::trie_builder< Context, Dir >::add_words(), vcsn::dyn::ambiguous_word(), vcsn::detail::is_ambiguous_impl< Aut >::ambiguous_word(), vcsn::is_partial_identity(), vcsn::detail::worded_automaton< Aut >::worded_labelset< tupleset< LabelSet... > >::labelset_(), make_word_context(), vcsn::dyn::synchronizing_word(), vcsn::detail::law_traits< tupleset< LabelSets... > >::value(), and vcsn::nullableset< LabelSet >::word().

template<Automaton Aut, typename ValueSet , typename Mul , typename GetValue >

auto vcsn::detail::make_yen	(	const Aut &	aut,
		const ValueSet &	vs,
		Mul	mul,
		GetValue	get_value
	)

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

Referenced by vcsn::k_lightest_path().

template<typename Fun , typename... Ts>

auto vcsn::detail::map	(	const std::tuple< Ts... > &	ts,
		Fun	f
	)		-> decltype(map_tuple_(f, ts, make_index_sequence<sizeof...(Ts)>()))

Map a function on a tuple, return tuple of the results.

Definition at line 177 of file tuple.hh.

References map_impl_().

Referenced by vcsn::detail::trie_builder< Context, Dir >::add(), vcsn::detail::efsmer< Aut >::arc_type_(), vcsn::detail::transition_map< automaton_t, weightset_t_of< automaton_t >, true, true >::build_map_(), vcsn::dyn::detail::codeterminize_(), vcsn::detail::derived_term_algo::derived_term_algo(), vcsn::dyn::detail::determinize_(), vcsn::detail::minimizer< Aut, moore_tag >::out_class(), and vcsn::detail::properer< Aut >::remover_().

Here is the call graph for this function:

template<typename Fun , typename... Ts, size_t... I>

auto vcsn::detail::map_impl_	(	Fun	f,
		const std::tuple< Ts... > &	ts,
		index_sequence< I... >
	)

Definition at line 185 of file tuple.hh.

Referenced by map(), and vcsn::detail::tupleset_impl< ValueSets >::map_().

template<typename Container >

Container::value_type vcsn::detail::max_forward ( const Container & container )

Same as *std::max_element, but works with an input iterator, not just a forward iterator.

Definition at line 121 of file algorithm.hh.

References vcsn::res.

template<Automaton... Auts>

auto vcsn::detail::meet_automata ( Auts &&... auts ) -> decltype(pass(auts->null_state()...), make_mutable_automaton(meet(auts->context()...)))

An automaton whose type is the meet between those of auts.

Definition at line 49 of file join-automata.hh.

References vcsn::make_mutable_automaton(), and vcsn::meet().

Referenced by conjunction(), and conjunction_lazy().

Here is the call graph for this function:

template<typename Range , typename Predicate >

bool vcsn::detail::none_of	(	const Range &	r,
		Predicate	p
	)

Definition at line 139 of file algorithm.hh.

Referenced by none_of_equal().

template<typename Range , typename Value >

bool vcsn::detail::none_of_equal	(	const Range &	r,
		const Value &	value
	)

Definition at line 148 of file algorithm.hh.

References none_of(), and v.

Referenced by print_label_class().

Here is the call graph for this function:

template<Automaton... Auts>

auto vcsn::detail::nullable_join_automata ( Auts &&... auts ) -> decltype(pass(auts->null_state()...), make_mutable_automaton(nullable_join_context(auts...)))

An automaton whose type is the nullable join between those of auts.

Definition at line 39 of file join-automata.hh.

References vcsn::make_mutable_automaton(), and nullable_join_context().

Referenced by make_join_automaton().

Here is the call graph for this function:

template<Automaton... Auts>

auto vcsn::detail::nullable_join_context ( Auts &&... auts ) -> decltype(pass(auts->null_state()...), make_nullableset_context(join(auts->context()...)))

The nullable context of the join between parameters' context.

Definition at line 29 of file join-automata.hh.

References vcsn::join(), and make_nullableset_context().

Referenced by nullable_join_automata().

Here is the call graph for this function:

template<Automaton Aut>

size_t vcsn::detail::num_lazy_states ( const Aut & a )

Definition at line 57 of file info.hh.

References vcsn::res.

Referenced by vcsn::info().

template<Automaton Aut>

ATTRIBUTE_CONST std::enable_if_t<!labelset_t_of<Aut>::has_one(), size_t> vcsn::detail::num_spontaneous_transitions ( const Aut & )

Definition at line 36 of file info.hh.

Referenced by vcsn::info().

template<Automaton Aut>

std::enable_if_t<labelset_t_of<Aut>::has_one(), size_t> vcsn::detail::num_spontaneous_transitions ( const Aut & aut )

Definition at line 43 of file info.hh.

References vcsn::res, and transitions().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::out	(	const Aut &	aut,
		state_t_of< Aut >	s
	)

Indexes of visible transitions leaving state s.

Invalidated by del_transition() and del_state().

Definition at line 84 of file automaton.hh.

References all_out().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::out	(	const Aut &	aut,
		state_t_of< Aut >	s,
		label_t_of< Aut >	l
	)

Indexes of all transitions leaving state s on label l.

Invalidated by del_transition() and del_state().

Definition at line 97 of file automaton.hh.

References all_out().

Here is the call graph for this function:

template<Automaton Aut>

auto vcsn::detail::outin	(	const Aut &	aut,
		state_t_of< Aut >	s,
		state_t_of< Aut >	d
	)

Indexes of visible transitions from state s to state d.

Invalidated by del_transition() and del_state().

Definition at line 187 of file automaton.hh.

References all_out().

Referenced by del_transition(), vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_(), and vcsn::detail::state_eliminator< Aut, Profiler >::eliminate_state_impl_().

Here is the call graph for this function:

template<typename... Args>

std::ostream& vcsn::detail::print	(	const std::tuple< Args... > &	args,
		std::ostream &	o
	)

Definition at line 374 of file tuple.hh.

template<typename T >

void vcsn::detail::print_	(	std::ostream &	o,
		const T &	arg,
		long
	)

Serialize arg into o.

Definition at line 26 of file raise.hh.

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

void vcsn::detail::print_	(	std::ostream &	o,
		std::istream &	is,
		long
	)

inline

When printing an istream, consider that we are trying to help the user by showing what's wrong with the input.

So report some of the upcoming bytes.

Definition at line 34 of file raise.hh.

References vcsn::str_escape().

Here is the call graph for this function:

void vcsn::detail::print_	(	std::ostream &	o,
		std::istringstream &	is,
		long
	)

inline

Disambiguation: both 'istream&' and 'const T&' are elligible.

Definition at line 46 of file raise.hh.

References print_().

Here is the call graph for this function:

template<typename T >

auto vcsn::detail::print_	(	std::ostream &	o,
		const T &	arg,
		int
	)		-> decltype(arg.print_set(o), void())

Serialize arg, which supports print_set, into o.

Serialize std::exception, namely RuntimeErrors.

Definition at line 53 of file raise.hh.

template<typename LabelSet >

std::ostream& vcsn::detail::print_label_class	(	const LabelSet &	ls,
		const std::vector< typename LabelSet::value_t > &	letters,
		std::ostream &	out,
		format	fmt
	)

Print a set of labels (letterized) with classes.

The order of the letters is respected; depending on the use case, you might want to call sort and unique before.

Definition at line 326 of file labelset.hh.

References vcsn::format::latex, none_of_equal(), out(), and print_label_ranges_().

Referenced by vcsn::rat::printer< ExpSet >::for(), and vcsn::detail::polynomialset_impl< Context, Kind >::print_with_classes_().

Here is the call graph for this function:

template<typename LabelSet >

std::ostream& vcsn::detail::print_label_ranges_	(	const LabelSet &	ls,
		const std::vector< typename LabelSet::value_t > &	letters,
		const std::vector< typename LabelSet::value_t > &	alphabet,
		std::ostream &	out,
		format	fmt
	)

Print a set of labels with ranges.

The order of the letters is respected; depending on the use case, you might want to call sort and unique before.

Definition at line 292 of file labelset.hh.

References vcsn::format::latex, and out().

Referenced by print_label_class().

Here is the call graph for this function:

template<size_t Tape, typename LabelSet , typename WeightSet >

auto vcsn::detail::project ( const context< LabelSet, WeightSet > & ctx ) -> std::enable_if_t<!is_multitape< LabelSet >

The resulting apparent context when keeping only tape Tape.

When the labelset is not a tupleset, require the tape to be 0, and return it.

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

template<size_t Tape, typename Context >

auto vcsn::detail::project ( const expressionset< Context > & rs )

Project an expressionset to one tape.

Definition at line 40 of file project.hh.

References vcsn::make_expressionset().

Here is the call graph for this function:

template<size_t Tape, typename ValueSet >

auto vcsn::detail::project	(	const ValueSet &	vs,
		const typename ValueSet::value_t &	v
	)

Project a value to one tape.

Used for expansion, expression, labels and polynomials.

Definition at line 59 of file project.hh.

References v.

template<size_t Tape, typename Context , wet_kind_t Kind>

auto vcsn::detail::project ( const polynomialset< Context, Kind > & ps )

Project a polynomialset to one tape.

Definition at line 116 of file project.hh.

References make_polynomialset().

Here is the call graph for this function:

std::string vcsn::detail::quote ( const std::string & s )

Turn a label into a parsable label: escape special characters.

Definition at line 23 of file trie.hh.

Referenced by vcsn::lazy_automaton_editor::add_transition(), and vcsn::detail::trie_builder< Context, Dir >::add_words().

template<Automaton Aut>

auto vcsn::detail::real_context ( const Aut & aut ) -> decltype(real_context_impl<Aut>::context(aut))

For a focus automaton, its genuine context (not the visible one), and for all the other automata, their context.

Definition at line 73 of file copy.hh.

References vcsn::detail::real_context_impl< Aut >::context().

Referenced by vcsn::detail::real_context_impl< automaton_decorator< Aut > >::context(), and vcsn::make_fresh_automaton().

Here is the call graph for this function:

template<typename... Ts>

auto vcsn::detail::reverse_tuple ( const std::tuple< Ts... > & t ) -> decltype(reverse_tuple(t, make_index_sequence<sizeof...(Ts)>()))

Definition at line 315 of file tuple.hh.

Referenced by make_gcc_tuple().

template<typename... Ts, std::size_t... I>

auto vcsn::detail::reverse_tuple	(	const std::tuple< Ts... > &	t,
		index_sequence< I... >
	)		-> decltype(std::make_tuple(std::get<sizeof...(Ts) - 1 - I>(t)...))

Definition at line 323 of file tuple.hh.

template<Automaton Aut>

size_t vcsn::detail::states_size ( const Aut & aut )

The largest state number, plus one.

Used to compute the size of state-indexed vectors.

Definition at line 39 of file automaton.hh.

Referenced by vcsn::all_distances(), bellman_ford_impl(), vcsn::format_lightest(), vcsn::minimize(), vcsn::detail::dijkstra_impl< Aut, ValueSet, Mul >::operator()(), vcsn::detail::a_star_impl< Aut >::operator()(), vcsn::detail::evaluator< Aut >::operator()(), vcsn::partial_identity(), vcsn::detail::efsmer< Aut >::print_transition_(), and vcsn::ss_shortest_distance().

template<typename Then , typename Else >

auto vcsn::detail::static_if	(	std::true_type	,
		Then &&	then,
		Else &&
	)

Execute the then-clause.

Definition at line 13 of file static-if.hh.

Referenced by vcsn::detail::tuple_automata_impl< Aut, Auts >::add_tape_transitions_(), and static_if().

template<typename Then , typename Else >

auto vcsn::detail::static_if	(	std::false_type	,
		Then &&	,
		Else &&	else_
	)

Execute the else-clause.

Definition at line 20 of file static-if.hh.

template<bool cond, typename Then , typename Else >

auto vcsn::detail::static_if	(	Then &&	then,
		Else &&	else_
	)

Execute the then- or the else-clause depending on cond.

Definition at line 27 of file static-if.hh.

References static_if().

Here is the call graph for this function:

template<bool cond, typename Then >

auto vcsn::detail::static_if ( Then && then )

Execute the then-clause if cond is verified.

Definition at line 36 of file static-if.hh.

template<Automaton Aut>

auto vcsn::detail::strip	(	const Aut &	aut,
		int
	)		-> decltype(aut->strip())

Definition at line 15 of file strip.hh.

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::conjunction(), vcsn::detail::universal_impl< Aut >::operator()(), and vcsn::strip().

template<Automaton Aut>

auto vcsn::detail::strip	(	const Aut &	aut,
		long
	)		-> decltype(aut)

Definition at line 24 of file strip.hh.

template<Automaton Aut>

synchronizer<Aut>::out_automaton_t vcsn::detail::synchronize ( const Aut & aut )

Definition at line 332 of file synchronize.hh.

References vcsn::detail::synchronizer< Aut >::synchronize().

Here is the call graph for this function:

template<typename Container , typename Fun >

auto vcsn::detail::transform	(	const Container &	c,
		Fun &&	fun
	)

Map a unary function on a container of values, and return the vector the results.

Definition at line 157 of file algorithm.hh.

References vcsn::res.

Referenced by vcsn::minimize(), vcsn::detail::random_expression_impl< ExpressionSet, RandomGenerator >::parse_param_(), vcsn::detail::random_weight_base< zmin, RandomGenerator >::parse_param_(), and vcsn::rat::dot_printer< ExpSet >::print_().

template<Automaton Aut>

auto vcsn::detail::transitions ( const Aut & aut ) -> decltype(all_transitions(aut, is_special_t<Aut>

All the transition indexes between visible states.

Definition at line 246 of file automaton.hh.

Referenced by absval(), bellman_ford_impl(), vcsn::detail::epsilon_remover< Aut, has_one >::in_situ_remover_(), is_letterized(), is_proper_(), vcsn::detail::left_reductioner< Aut >::linear_representation(), num_spontaneous_transitions(), vcsn::detail::epsilon_remover< Aut, has_one >::num_spontaneous_transitions_(), vcsn::detail::epsilon_remover_separate< transpose_in_automaton_t >::operator()(), and vcsn::detail::dot::parser::parse().

template<Automaton Aut>

size_t vcsn::detail::transitions_size ( const Aut & aut )

The largest transition number, plus one.

Used to compute the size of transition-indexed vectors.

Definition at line 49 of file automaton.hh.

template<Automaton... Auts>

auto vcsn::detail::tuple ( const Auts &... as )

Build the (accessible part of the) tuple.

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

References ctx, vcsn::make_mutable_automaton(), vcsn::res, and vcsn::tuple_context().

Referenced by vcsn::automatonset< context_t_of< automaton_t >, tag_t >::tuple().

Here is the call graph for this function:

vcsn::detail::VCSN_JOIN_SIMPLE	(	b	,
		b
	)

static weight_tapes_t::value_t vcsn::detail::weight_label ( const in_label_t & l )

static

Weight in the output.

Definition at line 173 of file lift.hh.

References weight_label_().

Here is the call graph for this function:

template<size_t... I>

static weight_tapes_t::value_t vcsn::detail::weight_label_	(	const in_label_t &	l,
		seq< I... >
	)

static

Definition at line 180 of file lift.hh.

Referenced by weight_label().

template<typename Key , typename Value >

constexpr wet_kind_t vcsn::detail::wet_kind ( )

Given a Key and a Value type, the appropriate weighted set type.

Definition at line 814 of file wet.hh.

Variable Documentation

vcsn::detail::context< LabelSet, WeightSet >

Initial value:

{
      static_assert(Tape == 0,
                    "project: cannot extract non-0 tape from a non tupleset"
                    " labelset")

Definition at line 37 of file project-context.hh.

return vcsn::detail::ctx

Definition at line 41 of file project-context.hh.

Referenced by vcsn::cerny(), vcsn::de_bruijn(), vcsn::divkbaseb(), vcsn::double_ring(), vcsn::join_weightset_expressionset(), vcsn::dyn::lweight(), vcsn::detail::polynomialset_impl< Context, Kind >::make(), vcsn::make_mutable_automaton(), make_proper_context(), make_word_polynomialset(), vcsn::minimize(), vcsn::detail::pair_automaton_impl< Aut >::pair_automaton_impl(), vcsn::ast::parse_context(), vcsn::quotkbaseb(), vcsn::random_automaton_deterministic(), vcsn::dyn::read_efsm(), vcsn::dyn::read_expression(), vcsn::read_label(), vcsn::read_polynomial(), vcsn::read_weight(), vcsn::lazy_automaton_editor::result(), vcsn::dyn::rweight(), vcsn::thompson(), vcsn::dyn::thompson(), tuple(), vcsn::tuple_context(), vcsn::tuple_expressionset(), vcsn::tuple_polynomialset(), vcsn::u(), vcsn::detail::lifter_impl< Context, vcsn::detail::index_sequence<> >::value(), vcsn::dyn::weight_series(), vcsn::zpc(), and vcsn::dyn::zpc().

auto vcsn::detail::ictx = inner_context_t{weight_tapes, *ctx.weightset()}

Definition at line 151 of file lift.hh.

xalloc<long int> vcsn::detail::indentation

Definition at line 18 of file indent.cc.

Referenced by vcsn::decindent(), vcsn::incindent(), vcsn::indent(), and vcsn::resetindent().

vcsn::detail::project_context< Tape, context< LabelSet, WeightSet > >

Initial value:

{
      
      return {ctx.labelset()->template project<Tape>(), *ctx.weightset()}

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

vcsn::detail::return {ls, rs}

Definition at line 154 of file lift.hh.

auto vcsn::detail::rs = weightset_t{ictx, ids}

Definition at line 152 of file lift.hh.

template<typename... LabelSets, typename WeightSet , size_t... Tapes>

struct lifter_impl< context< tupleset< LabelSets... >, WeightSet >, vcsn::detail::index_sequence< Tapes... >, std::enable_if_t<(0< sizeof...(Tapes))> > { using in_labelset_t=tupleset< LabelSets... >; using in_context_t=context< in_labelset_t, WeightSet >; using in_label_t=typename in_labelset_t::value_t; template< std::size_t...I > using seq=detail::index_sequence< I... >; template< typename S, typename L > struct tape_set; template< typename LabelSet > struct tape_set< seq<>, LabelSet > { using type=oneset; }; template< size_t...I, typename LabelSet > struct tape_set< seq< I... >, LabelSet > { using type=tupleset< typename LabelSet::template valueset_t< I >... >; }; using index_t =typename detail::make_index_sequence< in_labelset_t::size()>::type; static constexpr size_t number_of_tapes=in_labelset_t::size(); template< size_t I > using tape_labelset_t=typename in_labelset_t::template valueset_t< I >; using kept_index_t =sequence_difference< index_t, seq< Tapes... > >; using labelset_t=typename tape_set< kept_index_t, in_labelset_t >::type; using weight_index_t=seq< Tapes... >; using weight_tapes_t =typename tape_set< weight_index_t, in_labelset_t >::type; using inner_context_t=context< weight_tapes_t, WeightSet >; using weightset_t=expressionset< inner_context_t >; using context_t=context< labelset_t, weightset_t >; static context_t value(const in_context_t &ctx, vcsn::rat::identities ids) { return value_(ctx, ids, weight_index_t{}, kept_index_t{}); } template< size_t...WeightTapes, size_t...KeptTapes > static context_t value_(const in_context_t &ctx, vcsn::rat::identities ids, seq< WeightTapes... >, seq< KeptTapes... >) { auto ls=labelset_t{ctx.labelset() -> template vcsn::detail::set< KeptTapes >()...}

Specialization: lift only some tapes.

Definition at line 146 of file lift.hh.

vcsn::detail::v

Initial value:

{

auto hasher = std::hash<T>{}

vcsn::detail::hasher

return hasher(v)

Definition at line 32 of file functional.hh.

vcsn::detail::void

Initial value:

{

fado(aut, out)

vcsn::fado

std::ostream & fado(const Aut &aut, std::ostream &out=std::cout)

Format automaton to FAdo format.

Definition: grail.hh:115

vcsn::detail::out

auto out(const Aut &aut, state_t_of< Aut > s)

Indexes of visible transitions leaving state s.

Definition: automaton.hh:84

Definition at line 48 of file print.hh.

Referenced by vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::add_one_transitions_(), vcsn::detail::product_automaton_impl< Lazy, Aut, Auts >::add_shuffle_transitions_(), vcsn::zipped_maps< Dereference, Maps >::iterator::align_(), vcsn::all(), vcsn::detail::dot::parser::basic_symbol< Base >::basic_symbol(), vcsn::rat::parser::basic_symbol< Base >::basic_symbol(), vcsn::detail::dot::parser::basic_symbol< Base >::clear(), vcsn::rat::parser::basic_symbol< Base >::clear(), for_(), std::hash< std::tuple< Elements... > >::hash_(), vcsn::cross_sequences< Sequences >::cross_iterator< ValueType, IteratorsType >::increment_(), vcsn::rat::info< ExpSet >::visit_tuple< Dummy >::info_(), vcsn::detail::tupleset_impl< ValueSets >::lnormalize_here_(), vcsn::weightset_mixin< expressionset_t >::mul(), vcsn::zip_sequences< Sequences >::zip_iterator< ValueType, IteratorsType >::next_(), vcsn::zip_sequences_padded< ZipSequences >::zip_iterator< ValueType, IteratorsType >::next_(), vcsn::detail::tupleset_impl< ValueSets >::open_(), vcsn::any::operator()(), vcsn::rat::dot_printer< ExpSet >::visit_tuple< Dummy >::print_(), vcsn::detail::tupleset_impl< ValueSets >::print_(), vcsn::detail::tuple_automaton_impl< Aut, Auts >::print_set_(), vcsn::detail::tupleset_impl< ValueSets >::print_set_(), vcsn::raise(), vcsn::cross_sequences< Sequences >::cross_iterator< ValueType, IteratorsType >::reset_up_to_(), vcsn::detail::wet_set< Key, Compare >::set(), vcsn::detail::wet_bitset::set(), vcsn::transition_tuple< State, Label, bool >::set_weight(), vcsn::rat::sizer< ExpSet >::visit_tuple< Dummy >::size_(), vcsn::detail::tuple_automaton_impl< Aut, Auts >::sname_(), vcsn::rat::info< ExpSet >::VCSN_RAT_VISIT(), vcsn::detail::welement_weight< bool >::weight(), and vcsn::detail::welement_weight< bool >::welement_weight().

auto vcsn::detail::weight_tapes = weight_tapes_t{ctx.labelset()->template set<WeightTapes>()...}

Definition at line 150 of file lift.hh.

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation