awali::sttc::internal Namespace Reference

Implementation details of static layer (not stable). More...

Data Structures
struct	aff
struct	allowworder
class	are_isomorphicer
struct	as_pair
struct	as_tuple
class	automaton_decorator
	Aggregate an automaton, and forward calls to it. More...
struct	backward_initialisation
struct	backward_initialisation< Aut, b >
struct	bitset_iterator
struct	comp_tail_tuple
struct	comp_tail_tuple< N, N >
class	composer
	Build the (accessible part of the) composition. More...
struct	concat_tupleset
struct	concat_tupleset< tupleset< T1... >, tupleset< T2... > >
struct	cont_filter
struct	context_of
struct	context_of< sttc::mutable_automaton< Context > >
struct	context_t_of_impl
struct	context_t_of_impl< std::shared_ptr< ValueSet > >
struct	copier
	Copy an automaton. More...
struct	cross_sequences
class	cycle_identity_impl
	Whether the weight of beetween two states on component, it is always unique. More...
class	dautter
	Format an automaton into daut vcsn format. More...
struct	derived_termer
class	determinization_bitset_impl
	The subset construction automaton from another. More...
class	determinization_set_impl
	The subset construction automaton from another. More...
class	detweighted_algo_impl
	The weighted determinization of weighted automaton. More...
struct	dispatch_lal_lan
struct	dispatch_lal_lan< Aut, letterset< T > >
struct	dispatch_lal_lan< Aut, nullableset< T > >
class	dotter
	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
	Format automaton to EFSM format, based on FSM format. More...
class	enumerater
class	evaluator
struct	exp_parser
struct	extended_label
struct	extended_label< Aut, b >
class	fadoer
	Format an automaton into Fado. More...
class	gf2_impl
class	grailer
	Format an automaton into Fado. More...
struct	if_has_one
struct	if_has_one< true >
struct	imagers
struct	indice_filter
class	is_quotient_computer_t
struct	is_synchronizable_impl
class	is_valider
class	is_valider< Aut, false >
struct	it_cont
struct	it_filter
struct	it_indice_filter
struct	js_exp_parser
struct	label_t_of_impl
struct	label_t_of_impl< std::shared_ptr< ValueSet > >
struct	labelset_t_of_impl
struct	labelset_t_of_impl< std::shared_ptr< ValueSet > >
struct	labelset_types
	A traits so that tupleset may define types that may exist. More...
struct	labelset_types< decltype(pass{typename ValueSets::word_t()...}, void()), ValueSets... >
	Specialization for tuples of labelsets. More...
class	less
	adapter of std::less to wrap less_than method of valuesets More...
struct	letterizer
struct	letterizer< Aut, wordset< L > >
struct	lhm_values
struct	lhm_values_const_iterator
struct	linked_hash_map
struct	make_labelset_from_letters
struct	make_labelset_from_letters< nullableset< LS > >
struct	map_nullable
struct	map_nullable< tupleset< Letterset, T... > >
struct	map_nullable< tupleset<> >
class	merger
struct	multituple
struct	multituple< 1u >
struct	multitupleset
struct	multitupleset< 1u, Labelset >
class	mutable_automaton_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...
class	outputter
	Factor common bits in automaton formatting. More...
class	outsplitter
class	pair_automaton_impl
struct	partial_identiter
class	partition_automaton_impl
struct	pass
	Ignore its arguments. More...
class	permutation_automaton_impl
struct	possibly_labeled_transition_tuple
struct	possibly_labeled_transition_tuple< State, empty_t >
class	product_algo_impl
	Build the (accessible part of the) product. More...
struct	projector
struct	projectors
class	properer
	This class contains the core of the proper algorithm. More...
class	properer< Aut, false >
struct	random_selector
struct	rank
	Number of tapes. More...
struct	rank< tupleset< LabelSet... > >
class	ratexp_automaton_impl
	An incremental automaton whose states are ratexps. More...
struct	realtimer
class	reductioner
struct	rem_in_tuple
struct	rem_in_tuple< 0u >
struct	rem_in_tupleset
struct	rem_in_tupleset< tupleset< T... >, I >
struct	replace_in_tuple
struct	replace_in_tuple< 0u, T >
struct	replace_in_tupleset
struct	replace_in_tupleset< tupleset< T... >, I, U >
class	reverse_postorder_impl
	Get all vertexs in reverse postorder by using depth first search. More...
class	scc_kosaraju
	Use Kosajaju algorithm for finding all of strongly connected components. More...
struct	select
struct	select< q >
struct	select< r >
struct	select< tupleset< T... >, I >
struct	select< z >
struct	select_one
struct	select_one< tupleset< T... >, I >
struct	select_tail
struct	select_tail< tupleset< T... > >
struct	selects
struct	selects< tupleset< T... >, I... >
struct	standard_operations
class	star_heighter
struct	state_eliminator
struct	state_eliminator< Aut, labels_are_one >
struct	state_eliminator< Aut, labels_are_ratexps >
struct	sub_tuple
struct	sub_tuple< I >
class	synchronizer
struct	tail_tuple
struct	tail_tuple< std::tuple< Head, Tail... > >
class	tarjaner_t
struct	tdc_letterizer
struct	tdc_letterizer< Tdc, I, wordset< L > >
struct	tdc_lifter
class	tikzer
	Format automaton to TikZ format. More...
struct	trans_tuple
struct	transition_map
	Cache the outgoing transitions of an automaton as efficient maps label -> vector<(weight, dst)>. More...
class	transpose_view_impl
class	transposer
class	tuple_automaton_impl
	An automaton whose states are tuples of states of automata. More...
struct	tuple_to_tupleset
struct	tuple_to_tupleset< std::tuple< T... > >
class	universaler
	Functor for universal. More...
struct	weight_t_of_impl
struct	weight_t_of_impl< std::shared_ptr< ValueSet > >
struct	weightset_t_of_impl
struct	weightset_t_of_impl< std::shared_ptr< ValueSet > >
class	z_impl
struct	zip_sequences
struct	zipped_maps

Typedefs
template<typename T >
using	base_t = typename std::remove_cv< typename std::remove_reference< T >::type >::type
	T without reference or const/volatile qualifiers. More...
template<typename ValueSet >
using	context_of_t = typename context_of< ValueSet >::type
template<typename LabelSet >
using	law_t = typename labelset_trait< LabelSet >::wordset_t
template<typename Aut >
using	lifted_automaton_t = mutable_automaton< lifted_context_t< context_t_of< Aut > >>
template<typename Context >
using	lifted_context_t = context< oneset, ratexpset_of< Context > >
template<typename Exp >
using	lifted_ratexp_t = typename lifted_context_t< context_t_of< Exp > >::ratexp_t
template<typename RatExpSet >
using	lifted_ratexpset_t = ratexpset< lifted_context_t< context_t_of< RatExpSet > >>
template<typename Ctx >
using	word_context_t = context< law_t< labelset_t_of< Ctx > >, weightset_t_of< Ctx > >
template<typename Ctx >
using	word_polynomialset_t = polynomialset< word_context_t< Ctx > >

Functions
template<typename Aut >
Aut::element_type::automaton_nocv_t	absval (const Aut &aut)
	Copy of aut, with absolute values. More...
void	append (std::string &s, char c)
void	append (std::string &s, const std::string t)
template<typename Aut1 , typename Aut2 , typename P >
auto	are_equivalent_ (const Aut1 &aut1, const Aut2 &aut2, priority::FIVE< P >) -> typename std::enable_if<(labelset_t_of< Aut1 >::is_free() &&std::is_same< weightset_t_of< Aut1 >, b >::value &&labelset_t_of< Aut2 >::is_free() &&std::is_same< weightset_t_of< Aut2 >, b >::value), bool >::type
	Check equivalence between Boolean automata on a free labelset. More...
template<typename Aut1 , typename Aut2 , typename T >
auto	are_equivalent_ (const Aut1 &aut1, const Aut2 &aut2, priority::FOUR< T >) -> decltype(aut2->weightset() ->sub, aut2->weightset() ->zero, aut2->weightset() ->one, bool())
	Check equivalence between automata on fields, or Z. More...
template<typename Aut1 , typename Aut2 , typename P >
bool	are_equivalent_ (const Aut1 &aut1, const Aut2 &aut2, priority::ONE< P >)
template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >
size_t	collision_count (const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &m)
	Sum of bucket sizes. More...
template<size_t I, size_t J, typename Tuple1 , typename Tuple2 >
auto	concat_and_remove (const Tuple1 &t1, const Tuple2 &t2) -> typename std::concat_tuple< typename rem_in_tuple< I >::template type< Tuple1 >, typename rem_in_tuple< J >::template type< Tuple2 >>::type
template<typename A , typename B , typename P >
A &	concatenate_here (A &res, B b, priority::ONE< P >)
template<typename A , typename B , typename P >
auto	concatenate_here (A &res, B b, priority::TWO< P >) -> typename std::enable_if< labelset_t_of< A >::has_one(), A & >::type
template<typename Fun >
void	cross (Fun f)
	Variadic Cartesian product of vectors. More...
template<typename Fun , typename H , typename... Ts>
void	cross (Fun f, std::vector< H > const &h, std::vector< Ts > const &... ts)
template<typename... Sequences>
cross_sequences< Sequences... >	cross (Sequences &&... seqs)
template<typename... Sequences>
cross_sequences< Sequences... >	cross_tuple (const std::tuple< Sequences... > &seqs)
template<typename Fun , typename... Ts>
void	cross_tuple (Fun f, const std::tuple< Ts... > &ts)
template<typename Fun , typename... Ts, size_t... I>
void	cross_tuple_ (Fun f, const std::tuple< Ts... > &ts, awali::internal::index_sequence< I... >)
static int	debug_level ()
	Debug level set in the user's environment. More...
double	evalf (const q_fraction_t &x)
template<typename T >
T	evalf (const T &x)
template<typename T , typename Alloc >
ATTRIBUTE_PURE auto	find (const std::vector< T, Alloc > &s, const T &e) -> typename std::vector< T, Alloc >::const_iterator
	Convenience wrapper around std::find. More...
template<size_t N>
auto	get_iterator (const std::bitset< N > &bs) -> bitset_iterator< N >
template<typename T >
std::set< T >	get_union (const std::set< T > &set1, const std::set< T > &set2)
template<typename T , typename Compare , typename Alloc >
std::set< T, Compare, Alloc >	get_union (const std::set< T, Compare, Alloc > &set1, const std::set< T, Compare, Alloc > &set2)
	The union of two sets. More...
template<typename Key , typename Value , typename Compare , typename Alloc >
bool	has (const std::map< Key, Value, Compare, Alloc > &s, const Key &e)
template<typename T >
bool	has (const std::set< T > &s, const T &e)
template<typename T , typename Compare , typename Alloc >
bool	has (const std::set< T, Compare, Alloc > &s, const T &e) ATTRIBUTE_PURE
	Whether e is member of s. More...
template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >
bool	has (const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &m, const Key &k)
	Whether e is member of m. More...
template<typename Key , typename Hash , typename KeyEqual , typename Alloc >
bool	has (const std::unordered_set< Key, Hash, KeyEqual, Alloc > &s, const Key &k)
	Whether e is member of s. More...
template<typename T , typename Alloc >
ATTRIBUTE_PURE bool	has (const std::vector< T, Alloc > &s, const T &e)
	Whether e is member of s. More...
template<typename Key , typename Value , typename Comp , typename Alloc >
std::set< typename std::map< Key, Value, Comp, Alloc >::mapped_type >	image (const std::map< Key, Value, Comp, Alloc > &m)
	The set of values of a map. More...
template<typename Aut >
void	initialize_partition (const Aut &aut, std::vector< std::vector< state_t > > &states_in_part)
template<typename T >
std::set< T >	intersection (const std::set< T > &set1, const std::set< T > &set2)
template<typename T , typename Compare , typename Alloc >
std::set< T, Compare, Alloc >	intersection (const std::set< T, Compare, Alloc > &set1, const std::set< T, Compare, Alloc > &set2)
	The intersection of two sets. More...
template<typename T >
std::set< std::set< T > >	intersection_closure (std::set< std::set< T >> pset)
template<typename T , typename Compare , typename Alloc >
std::set< std::set< T, Compare, Alloc > >	intersection_closure (std::set< std::set< T, Compare, Alloc >> pset)
	The set of all the intersections of the sets in pset. More...
template<typename Aut >
bool	is_deterministic (const Aut &aut, state_t s)
	Whether state s is deterministic in aut. More...
template<typename WS , typename P >
constexpr bool	is_finite (const WS &, priority::ONE< P >)
template<typename WS , typename P >
constexpr auto	is_finite (const WS &, priority::TWO< P >) -> typename WS::finite_t
template<typename WS , typename P >
constexpr auto	is_locally_finite (const WS &, priority::TWO< P >) -> typename WS::locally_finite_t
template<typename WS , typename P >
constexpr bool	is_locally_finite (const WS &ws, priority::ONE< P >)
template<typename Aut >
constexpr std::enable_if<!labelset_t_of< Aut >::has_one(), bool >::type	is_proper_ (const Aut &)
template<typename Aut >
std::enable_if< labelset_t_of< Aut >::has_one(), bool >::type	is_proper_ (const Aut &aut)
template<size_t I, typename Tdc >
std::enable_if<!labelset_t_of< Tdc >::template valueset_t< I >::has_one(), bool >::type	is_proper_tape_ (const Tdc &)
template<typename Tdc >
constexpr std::enable_if<!labelset_t_of< Tdc >::has_one(), bool >::type	is_proper_tape_ (const Tdc &)
template<size_t I, typename Tdc >
std::enable_if< labelset_t_of< Tdc >::template valueset_t< I >::has_one(), bool >::type	is_proper_tape_ (const Tdc &tdc)
template<typename Aut >
bool	is_properable (Aut &&aut)
	Whether proper_here(aut) succeeds. More...
template<typename Aut >
bool	is_sequential (const Aut &aut, state_t s)
	Whether state s is sequential in aut. More...
template<typename LabelSet , typename WeightSet >
lifted_context_t< context< LabelSet, WeightSet > >	lift_context (const context< LabelSet, WeightSet > &ctx)
template<typename Context >
lifted_ratexpset_t< ratexpset< Context > >	lift_ratexpset (const ratexpset< Context > &rs)
std::complex< double >	lr_parse_complex (std::string const &s, size_t &p, bool allow_empty=false, std::complex< double > value_if_empty={0, 0})
	Reads a complex number left of position p in string, by using as many characters as possible. More...
char	lr_parse_dot (std::string const &s, size_t &p, bool allow_empty=true, char value_if_empty='\0')
double	lr_parse_double (std::string const &s, size_t &p, bool allow_empty=false, double value_if_empty=0)
	Reads a double left of position p in string, by using as many characters as possible. More...
char	lr_parse_e (std::string const &s, size_t &p, bool allow_empty=true, char value_if_empty='\0')
	Parses the radix point. More...
int	lr_parse_int (std::string const &s, size_t &p, bool allow_empty=false, int value_if_empty=0)
	Reads an int written in decimal left of position p in string s, by using as many characters as possible Parameter p is decreased by the number of characters thus consumed. More...
char	lr_parse_one (std::string const &s, size_t &p, char const *t, bool allow_empty=false, char value_if_empty='\0')
	Checks whether there is in t left of position p in s. More...
q_fraction_t	lr_parse_qfraction (std::string const &s, size_t &p, bool allow_empty=false, q_fraction_t value_if_empty={1, 1})
	Reads a q_fraction_t left of position p in string, by using as many characters as possible. More...
char	lr_parse_sign (std::string const &s, size_t &p, bool allow_empty=true, char value_if_empty='\0')
unsigned	lr_parse_uint (std::string const &s, size_t &p, bool allow_empty=false, unsigned value_if_empty=0)
	Reads an unsigned int written in decimal left of position p in string s, by using as many character as possible Parameter p is decreased by the number of characters thus consumed. More...
unsigned	lr_scan_complex (std::string const &s, size_t &pp)
unsigned	lr_scan_digits (std::string const &s, size_t &p)
	Scans for as many [0-9] digits as possible, left of position p in string s. More...
unsigned	lr_scan_dot (std::string const &s, size_t &p)
unsigned	lr_scan_double (std::string const &s, size_t &pp)
unsigned	lr_scan_e (std::string const &s, size_t &p)
unsigned	lr_scan_int (std::string const &s, size_t &p)
unsigned	lr_scan_one (std::string const &s, size_t &p, char const *t)
	Scans for a character in t left of position p in s. More...
unsigned	lr_scan_sign (std::string const &s, size_t &p)
template<typename RandomGenerator = std::default_random_engine>
struct random_selector< RandomGenerator >	make_random_selector (const RandomGenerator &g) ATTRIBUTE_PURE
template<typename LabelSet , typename WeightSet >
word_context_t< context< LabelSet, WeightSet > >	make_word_context (const context< LabelSet, WeightSet > &ctx)
	The wordset context of a labelset. More...
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 LabelSet >
law_t< LabelSet >	make_wordset (const LabelSet &ls)
	The wordset of a labelset. More...
template<class Aut >
size_t	num_deterministic_states (const Aut &aut)
	Number of non-deterministic states. More...
static unsigned	powten (unsigned i)
template<typename T >
std::ostream &	print (const std::set< T > &set, std::ostream &o)
template<typename T , typename Compare , typename Alloc >
std::ostream &	print (const std::set< T, Compare, Alloc > &set, std::ostream &o)
	Print with a separator. Meant to help debugging. More...
template<typename Ctx >
mutable_automaton< Ctx >	random (const Ctx &ctx, unsigned num_states, float density=0.1, unsigned num_initial=1, unsigned num_final=1)
template<typename Ctx >
mutable_automaton< Ctx >	random_deterministic (const Ctx &ctx, unsigned num_states)
template<typename LabelSet , typename RandomGenerator = std::default_random_engine>
LabelSet::value_t	random_label (const LabelSet &ls, RandomGenerator &gen=RandomGenerator())
template<typename LabelSet , typename RandomGenerator = std::default_random_engine>
nullableset< LabelSet >::value_t	random_label (const nullableset< LabelSet > &ls, RandomGenerator &gen=RandomGenerator())
template<typename RandomGenerator = std::default_random_engine>
oneset::value_t	random_label (const oneset &ls, RandomGenerator &=RandomGenerator())
template<typename Context , typename RandomGenerator = std::default_random_engine>
ratexpset< Context >::value_t	random_label (const ratexpset< Context > &rs, RandomGenerator &gen=RandomGenerator())
template<typename... LabelSet, size_t... I, typename RandomGenerator = std::default_random_engine>
tupleset< LabelSet... >::value_t	random_label (const tupleset< LabelSet... > &ls, RandomGenerator &gen, awali::internal::index_sequence< I... >)
template<typename... LabelSet, typename RandomGenerator = std::default_random_engine>
tupleset< LabelSet... >::value_t	random_label (const tupleset< LabelSet... > &ls, RandomGenerator &gen=RandomGenerator())
template<typename Aut , typename P >
Aut &	star_here (Aut &res, priority::ONE< P >)
	In place star of an automaton. More...
template<typename Aut , typename P >
auto	star_here (Aut &res, priority::TWO< P >) -> typename std::enable_if< labelset_t_of< Aut >::has_one(), Aut & >::type
template<typename Container1 , typename Container2 >
bool	subset (const Container1 &set1, const Container2 &set2) ATTRIBUTE_PURE
	Whether set1 ⊆ set2. More...
template<typename A , typename B >
A &	sum_of_standard_here (A &res, const B &b)
	Merge transitions of b into those of res. More...
template<typename Cont >
std::vector< typename Cont::value_type >	to_vector (const Cont &cont)
	Return the content of cont as a vector. More...
template<typename Tuple >
auto	tuple_tail (const Tuple &t) -> typename tail_tuple< Tuple >::type
template<typename Aut >
internal::lifted_automaton_t< Aut >	unnormalized_lift (const Aut &a, bool keep_history=true)
template<typename WS , typename W1 , typename... W>
auto	variadic_mul (const WS &weightset, const W1 &w1, const W &... w) -> typename WS::value_t
template<typename WS , typename W1 , typename W2 >
auto	variadic_mul (const WS &weightset, const W1 &w1, const W2 &w2) -> typename WS::value_t
template<typename... Sequences>
zip_sequences< Sequences... >	zip (Sequences &&... seqs)
template<typename Dereference = as_pair, typename... Maps>
zipped_maps< Dereference, Maps... >	zip_map_tuple (const std::tuple< Maps... > &maps)
template<typename Dereference = as_pair, typename... Maps>
zipped_maps< Dereference, Maps... >	zip_maps (Maps &&... maps)
template<typename... Sequences>
zip_sequences< Sequences... >	zip_tuple (const std::tuple< Sequences... > &seqs)

Detailed Description

Implementation details of static layer (not stable).

Append automaton b to res.

---

Data Structure Documentation

awali::sttc::internal::aff

struct awali::sttc::internal::aff

template<typename T>
struct awali::sttc::internal::aff< T >

awali::sttc::internal::as_pair

struct awali::sttc::internal::as_pair

awali::sttc::internal::as_tuple

struct awali::sttc::internal::as_tuple

awali::sttc::internal::concat_tupleset

struct awali::sttc::internal::concat_tupleset

template<typename T1, typename T2>
struct awali::sttc::internal::concat_tupleset< T1, T2 >

awali::sttc::internal::concat_tupleset< tupleset< T1... >, tupleset< T2... > >

struct awali::sttc::internal::concat_tupleset< tupleset< T1... >, tupleset< T2... > >

template<typename... T1, typename... T2>
struct awali::sttc::internal::concat_tupleset< tupleset< T1... >, tupleset< T2... > >

Data Fields
	type

awali::sttc::internal::context_of

struct awali::sttc::internal::context_of

template<typename ValueSet>
struct awali::sttc::internal::context_of< ValueSet >

Data Fields
typedef typename context_t	type

awali::sttc::internal::context_of< sttc::mutable_automaton< Context > >

struct awali::sttc::internal::context_of< sttc::mutable_automaton< Context > >

template<typename Context>
struct awali::sttc::internal::context_of< sttc::mutable_automaton< Context > >

Data Fields
typedef Context	type

awali::sttc::internal::context_t_of_impl

struct awali::sttc::internal::context_t_of_impl

template<typename ValueSet>
struct awali::sttc::internal::context_t_of_impl< ValueSet >

Data Fields
typedef typename context_t	type

awali::sttc::internal::label_t_of_impl

struct awali::sttc::internal::label_t_of_impl

template<typename ValueSet>
struct awali::sttc::internal::label_t_of_impl< ValueSet >

Data Fields
typedef typename label_t	type

awali::sttc::internal::labelset_t_of_impl

struct awali::sttc::internal::labelset_t_of_impl

template<typename ValueSet>
struct awali::sttc::internal::labelset_t_of_impl< ValueSet >

Data Fields
typedef typename labelset_t	type

awali::sttc::internal::labelset_types

struct awali::sttc::internal::labelset_types

template<typename Enable = void, typename... ValueSets>
struct awali::sttc::internal::labelset_types< Enable, ValueSets >

A traits so that tupleset may define types that may exist.

The types genset_t, letter_t, and word_t, exists only for tuples of labelsets, characterized as featuring a word_t type.

Data Fields
typedef void	genset_t
typedef void	letter_t
typedef void	word_t

awali::sttc::internal::labelset_types< decltype(pass{typename ValueSets::word_t()...}, void()), ValueSets... >

struct awali::sttc::internal::labelset_types< decltype(pass{typename ValueSets::word_t()...}, void()), ValueSets... >

template<typename... ValueSets>
struct awali::sttc::internal::labelset_types< decltype(pass{typename ValueSets::word_t()...}, void()), ValueSets... >

Specialization for tuples of labelsets.

Data Fields
	genset_t
	letter_t
	word_t

awali::sttc::internal::map_nullable

struct awali::sttc::internal::map_nullable

template<typename T>
struct awali::sttc::internal::map_nullable< T >

awali::sttc::internal::multitupleset

struct awali::sttc::internal::multitupleset

template<size_t N, typename Labelset>
struct awali::sttc::internal::multitupleset< N, Labelset >

Data Fields
typedef typename concat_tupleset< tupleset< Labelset >, typename multitupleset< N-1, Labelset >::type >::type	type

awali::sttc::internal::multitupleset< 1u, Labelset >

struct awali::sttc::internal::multitupleset< 1u, Labelset >

template<typename Labelset>
struct awali::sttc::internal::multitupleset< 1u, Labelset >

Data Fields
typedef tupleset< Labelset >	type

awali::sttc::internal::rem_in_tupleset

struct awali::sttc::internal::rem_in_tupleset

template<typename T, size_t I>
struct awali::sttc::internal::rem_in_tupleset< T, I >

awali::sttc::internal::replace_in_tupleset

struct awali::sttc::internal::replace_in_tupleset

template<typename T, size_t I, typename U>
struct awali::sttc::internal::replace_in_tupleset< T, I, U >

awali::sttc::internal::select_one

struct awali::sttc::internal::select_one

template<typename Labelset, size_t I>
struct awali::sttc::internal::select_one< Labelset, I >

awali::sttc::internal::select_tail

struct awali::sttc::internal::select_tail

template<typename Labelset, size_t... I>
struct awali::sttc::internal::select_tail< Labelset, I >

awali::sttc::internal::selects

struct awali::sttc::internal::selects

template<typename Labelset, size_t... I>
struct awali::sttc::internal::selects< Labelset, I >

awali::sttc::internal::state_eliminator

struct awali::sttc::internal::state_eliminator

template<typename Aut, typename Kind = typename context_t_of<Aut>::kind_t>
struct awali::sttc::internal::state_eliminator< Aut, Kind >

awali::sttc::internal::tail_tuple

struct awali::sttc::internal::tail_tuple

template<typename T>
struct awali::sttc::internal::tail_tuple< T >

awali::sttc::internal::tail_tuple< std::tuple< Head, Tail... > >

struct awali::sttc::internal::tail_tuple< std::tuple< Head, Tail... > >

template<typename Head, typename... Tail>
struct awali::sttc::internal::tail_tuple< std::tuple< Head, Tail... > >

Data Fields
	type

awali::sttc::internal::tuple_to_tupleset

struct awali::sttc::internal::tuple_to_tupleset

template<typename T>
struct awali::sttc::internal::tuple_to_tupleset< T >

awali::sttc::internal::tuple_to_tupleset< std::tuple< T... > >

struct awali::sttc::internal::tuple_to_tupleset< std::tuple< T... > >

template<typename... T>
struct awali::sttc::internal::tuple_to_tupleset< std::tuple< T... > >

Data Fields
	type

awali::sttc::internal::weight_t_of_impl

struct awali::sttc::internal::weight_t_of_impl

template<typename ValueSet>
struct awali::sttc::internal::weight_t_of_impl< ValueSet >

Data Fields
typedef typename weight_t	type

awali::sttc::internal::weightset_t_of_impl

struct awali::sttc::internal::weightset_t_of_impl

template<typename ValueSet>
struct awali::sttc::internal::weightset_t_of_impl< ValueSet >

Data Fields
typedef typename weightset_t	type

Typedef Documentation

base_t

template<typename T >

using awali::sttc::internal::base_t = typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type

T without reference or const/volatile qualifiers.

context_of_t

template<typename ValueSet >

using awali::sttc::internal::context_of_t = typedef typename context_of<ValueSet>::type

law_t

template<typename LabelSet >

using awali::sttc::internal::law_t = typedef typename labelset_trait<LabelSet>::wordset_t

lifted_automaton_t

template<typename Aut >

using awali::sttc::internal::lifted_automaton_t = typedef mutable_automaton<lifted_context_t<context_t_of<Aut> >>

lifted_context_t

template<typename Context >

using awali::sttc::internal::lifted_context_t = typedef context<oneset, ratexpset_of<Context> >

lifted_ratexp_t

template<typename Exp >

using awali::sttc::internal::lifted_ratexp_t = typedef typename lifted_context_t<context_t_of<Exp> >::ratexp_t

lifted_ratexpset_t

template<typename RatExpSet >

using awali::sttc::internal::lifted_ratexpset_t = typedef ratexpset<lifted_context_t<context_t_of<RatExpSet> >>

word_context_t

template<typename Ctx >

using awali::sttc::internal::word_context_t = typedef context<law_t<labelset_t_of<Ctx> >, weightset_t_of<Ctx> >

word_polynomialset_t

template<typename Ctx >

using awali::sttc::internal::word_polynomialset_t = typedef polynomialset<word_context_t<Ctx> >

Function Documentation

absval()

template<typename Aut >

Aut::element_type::automaton_nocv_t awali::sttc::internal::absval

(

const Aut &

aut

)

Copy of aut, with absolute values.

Templated to avoid useless instantiations.

append() [1/2]

void awali::sttc::internal::append	(	std::string &	s,
		char	c
	)

append() [2/2]

void awali::sttc::internal::append	(	std::string &	s,
		const std::string	t
	)

are_equivalent_() [1/3]

template<typename Aut1 , typename Aut2 , typename P >

auto awali::sttc::internal::are_equivalent_	(	const Aut1 &	aut1,
		const Aut2 &	aut2,
		priority::FIVE< P >
	)		-> typename std::enable_if<(labelset_t_of<Aut1>::is_free() && std::is_same<weightset_t_of<Aut1>, b>::value && labelset_t_of<Aut2>::is_free() && std::is_same<weightset_t_of<Aut2>, b>::value), bool>::type

Check equivalence between Boolean automata on a free labelset.

are_equivalent_() [2/3]

template<typename Aut1 , typename Aut2 , typename T >

auto awali::sttc::internal::are_equivalent_	(	const Aut1 &	aut1,
		const Aut2 &	aut2,
		priority::FOUR< T >
	)		-> decltype(aut2->weightset()->sub, aut2->weightset()->zero, aut2->weightset()->one, bool())

Check equivalence between automata on fields, or Z.

are_equivalent_() [3/3]

template<typename Aut1 , typename Aut2 , typename P >

bool awali::sttc::internal::are_equivalent_	(	const Aut1 &	aut1,
		const Aut2 &	aut2,
		priority::ONE< P >
	)

collision_count()

template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >

size_t awali::sttc::internal::collision_count

(

const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &

m

)

Sum of bucket sizes.

concat_and_remove()

template<size_t I, size_t J, typename Tuple1 , typename Tuple2 >

auto awali::sttc::internal::concat_and_remove	(	const Tuple1 &	t1,
		const Tuple2 &	t2
	)		-> typename std::concat_tuple< typename rem_in_tuple<I>::template type<Tuple1>, typename rem_in_tuple<J>::template type<Tuple2>>::type

concatenate_here() [1/2]

template<typename A , typename B , typename P >

A& awali::sttc::internal::concatenate_here	(	A &	res,
		B	b,
		priority::ONE< P >
	)

Precondition

The context of res must include that of b.

concatenate_here() [2/2]

template<typename A , typename B , typename P >

auto awali::sttc::internal::concatenate_here	(	A &	res,
		B	b,
		priority::TWO< P >
	)		-> typename std::enable_if<labelset_t_of<A>::has_one(),A&>::type

cross() [1/3]

template<typename Fun >

void awali::sttc::internal::cross

(

Fun

f

)

Variadic Cartesian product of vectors.

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

cross() [2/3]

template<typename Fun , typename H , typename... Ts>

void awali::sttc::internal::cross	(	Fun	f,
		std::vector< H > const &	h,
		std::vector< Ts > const &...	ts
	)

cross() [3/3]

template<typename... Sequences>

cross_sequences<Sequences...> awali::sttc::internal::cross

(

Sequences &&...

seqs

)

cross_tuple() [1/2]

template<typename... Sequences>

cross_sequences<Sequences...> awali::sttc::internal::cross_tuple

(

const std::tuple< Sequences... > &

seqs

)

cross_tuple() [2/2]

template<typename Fun , typename... Ts>

void awali::sttc::internal::cross_tuple	(	Fun	f,
		const std::tuple< Ts... > &	ts
	)

cross_tuple_()

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

void awali::sttc::internal::cross_tuple_	(	Fun	f,
		const std::tuple< Ts... > &	ts,
		awali::internal::index_sequence< I... >
	)

debug_level()

static int awali::sttc::internal::debug_level ( )

static

Debug level set in the user's environment.

evalf() [1/2]

double awali::sttc::internal::evalf

(

const q_fraction_t &

x

)

evalf() [2/2]

template<typename T >

T awali::sttc::internal::evalf

(

const T &

x

)

find()

template<typename T , typename Alloc >

ATTRIBUTE_PURE auto awali::sttc::internal::find	(	const std::vector< T, Alloc > &	s,
		const T &	e
	)		-> typename std::vector<T, Alloc>::const_iterator

Convenience wrapper around std::find.

get_iterator()

template<size_t N>

auto awali::sttc::internal::get_iterator

(

const std::bitset< N > &

bs

)

-> bitset_iterator<N>

get_union() [1/2]

template<typename T >

std::set<T> awali::sttc::internal::get_union	(	const std::set< T > &	set1,
		const std::set< T > &	set2
	)

get_union() [2/2]

template<typename T , typename Compare , typename Alloc >

std::set<T, Compare, Alloc> awali::sttc::internal::get_union	(	const std::set< T, Compare, Alloc > &	set1,
		const std::set< T, Compare, Alloc > &	set2
	)

The union of two sets.

has() [1/6]

template<typename Key , typename Value , typename Compare , typename Alloc >

bool awali::sttc::internal::has	(	const std::map< Key, Value, Compare, Alloc > &	s,
		const Key &	e
	)

has() [2/6]

template<typename T >

bool awali::sttc::internal::has	(	const std::set< T > &	s,
		const T &	e
	)

has() [3/6]

template<typename T , typename Compare , typename Alloc >

bool awali::sttc::internal::has	(	const std::set< T, Compare, Alloc > &	s,
		const T &	e
	)

Whether e is member of s.

has() [4/6]

template<typename Key , typename T , typename Hash , typename KeyEqual , typename Alloc >

bool awali::sttc::internal::has	(	const std::unordered_map< Key, T, Hash, KeyEqual, Alloc > &	m,
		const Key &	k
	)

Whether e is member of m.

has() [5/6]

template<typename Key , typename Hash , typename KeyEqual , typename Alloc >

bool awali::sttc::internal::has	(	const std::unordered_set< Key, Hash, KeyEqual, Alloc > &	s,
		const Key &	k
	)

Whether e is member of s.

has() [6/6]

template<typename T , typename Alloc >

ATTRIBUTE_PURE bool awali::sttc::internal::has	(	const std::vector< T, Alloc > &	s,
		const T &	e
	)

Whether e is member of s.

image()

template<typename Key , typename Value , typename Comp , typename Alloc >

std::set< typename std::map< Key, Value, Comp, Alloc >::mapped_type > awali::sttc::internal::image

(

const std::map< Key, Value, Comp, Alloc > &

m

)

The set of values of a map.

initialize_partition()

template<typename Aut >

void awali::sttc::internal::initialize_partition	(	const Aut &	aut,
		std::vector< std::vector< state_t > > &	states_in_part
	)

intersection() [1/2]

template<typename T >

std::set<T> awali::sttc::internal::intersection	(	const std::set< T > &	set1,
		const std::set< T > &	set2
	)

intersection() [2/2]

template<typename T , typename Compare , typename Alloc >

std::set<T, Compare, Alloc> awali::sttc::internal::intersection	(	const std::set< T, Compare, Alloc > &	set1,
		const std::set< T, Compare, Alloc > &	set2
	)

The intersection of two sets.

intersection_closure() [1/2]

template<typename T >

std::set<std::set<T> > awali::sttc::internal::intersection_closure

(

std::set< std::set< T >>

pset

)

intersection_closure() [2/2]

template<typename T , typename Compare , typename Alloc >

std::set<std::set<T, Compare, Alloc> > awali::sttc::internal::intersection_closure

(

std::set< std::set< T, Compare, Alloc >>

pset

)

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

is_deterministic()

template<typename Aut >

bool awali::sttc::internal::is_deterministic	(	const Aut &	aut,
		state_t	s
	)

Whether state s is deterministic in aut.

is_finite() [1/2]

template<typename WS , typename P >

constexpr bool awali::sttc::internal::is_finite ( const WS &  , priority::ONE< P >    )

constexpr

is_finite() [2/2]

template<typename WS , typename P >

constexpr auto awali::sttc::internal::is_finite ( const WS &  , priority::TWO< P >    ) -> typename WS::finite_t

constexpr

is_locally_finite() [1/2]

template<typename WS , typename P >

constexpr auto awali::sttc::internal::is_locally_finite ( const WS &  , priority::TWO< P >    ) -> typename WS::locally_finite_t

constexpr

is_locally_finite() [2/2]

template<typename WS , typename P >

constexpr bool awali::sttc::internal::is_locally_finite ( const WS &  ws, priority::ONE< P >    )

constexpr

is_proper_() [1/2]

template<typename Aut >

constexpr std::enable_if<!labelset_t_of<Aut>::has_one(), bool>::type awali::sttc::internal::is_proper_ ( const Aut &  )

constexpr

is_proper_() [2/2]

template<typename Aut >

std::enable_if<labelset_t_of<Aut>::has_one(), bool>::type awali::sttc::internal::is_proper_

(

const Aut &

aut

)

is_proper_tape_() [1/3]

template<size_t I, typename Tdc >

std::enable_if<!labelset_t_of<Tdc>::template valueset_t<I>::has_one(), bool>::type awali::sttc::internal::is_proper_tape_

(

const Tdc &

)

is_proper_tape_() [2/3]

template<typename Tdc >

constexpr std::enable_if<!labelset_t_of<Tdc>::has_one(), bool>::type awali::sttc::internal::is_proper_tape_ ( const Tdc &  )

constexpr

is_proper_tape_() [3/3]

template<size_t I, typename Tdc >

std::enable_if<labelset_t_of<Tdc>::template valueset_t<I>::has_one(), bool>::type awali::sttc::internal::is_proper_tape_

(

const Tdc &

tdc

)

is_properable()

template<typename Aut >

bool awali::sttc::internal::is_properable

(

Aut &&

aut

)

Whether proper_here(aut) succeeds.

Destroys aut.

is_sequential()

template<typename Aut >

bool awali::sttc::internal::is_sequential	(	const Aut &	aut,
		state_t	s
	)

Whether state s is sequential in aut.

lift_context()

template<typename LabelSet , typename WeightSet >

lifted_context_t<context<LabelSet, WeightSet> > awali::sttc::internal::lift_context

(

const context< LabelSet, WeightSet > &

ctx

)

lift_ratexpset()

template<typename Context >

lifted_ratexpset_t<ratexpset<Context> > awali::sttc::internal::lift_ratexpset

(

const ratexpset< Context > &

rs

)

lr_parse_complex()

std::complex<double> awali::sttc::internal::lr_parse_complex	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = false,
		std::complex< double >	value_if_empty = {0,0}
	)

Reads a complex number left of position p in string, by using as many characters as possible.

Acceptable format:

• <double>
• <double> i
• <double> [+|-] <double without sign or empty> i
• <double or empty> i [+|-] <double without sign>

Parameter p is decreased by the number of characters used.

Parameters

s	String in which the complex number is read.
p	Position left of which the complex number is read; it is decreased by the number of character effectively used.
allow_empty	Whether this function is allowed to read 0 characters; if set to false this function raises a parse_exception if it cannot read at least one valid character. Default is false.
value_if_empty	Value returned if no character was consumed and allow_empty is true. Default is 1.0.

Returns

The parsed complex number.

lr_parse_dot()

char awali::sttc::internal::lr_parse_dot	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = true,
		char	value_if_empty = '\0'
	)

lr_parse_double()

double awali::sttc::internal::lr_parse_double	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = false,
		double	value_if_empty = 0
	)

Reads a double left of position p in string, by using as many characters as possible.

Parameter p is decreased by the number of characters used.

Parameters

s	String in which the double is read.
p	Position left of which the double is read; it is decreased by the number of character effectively used.
allow_empty	Whether this function is allowed to read 0 characters; if set to false this function raises a parse_exception if it cannot read at least one valid character. Default is false.
value_if_empty	Value returned if no character was consumed and allow_empty is true. Default is 1.0.

Returns

The parsed double.

lr_parse_e()

char awali::sttc::internal::lr_parse_e	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = true,
		char	value_if_empty = '\0'
	)

Parses the radix point.

lr_parse_int()

int awali::sttc::internal::lr_parse_int	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = false,
		int	value_if_empty = 0
	)

Reads an int written in decimal left of position p in string s, by using as many characters as possible Parameter p is decreased by the number of characters thus consumed.

Parameters

s	String in which the int is read
p	Position left of which the int is read; decreased by the number of character effectively used.
allow_empty	Whether this function is allowed to read 0 characters; if set to false this function raises a parse_exception if it cannot read at least one valid character.
value_if_empty	Value returned if no character was consumes and allow_empty is true.

Returns

the parsed int

lr_parse_one()

char awali::sttc::internal::lr_parse_one	(	std::string const &	s,
		size_t &	p,
		char const *	t,
		bool	allow_empty = false,
		char	value_if_empty = '\0'
	)

Checks whether there is in t left of position p in s.

If a character is found, p is modified accordingly (i.e., decreased by 1) and the found character is returned. If no such character is found: if allow_empty is true then returns value_if_empty and p is not modified, otherwise, an exception is raised.

Returns

The found char or value_if_empty if none was found and allow_empty is true.

lr_parse_qfraction()

q_fraction_t awali::sttc::internal::lr_parse_qfraction	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = false,
		q_fraction_t	value_if_empty = {1,1}
	)

Reads a q_fraction_t left of position p in string, by using as many characters as possible.

Acceptable format:

• <int> / <uint>
• <int> . <uint> Parameter p is decreased by the number of characters used.

Parameters

s	String in which the q_fraction_t is read.
p	Position left of which the q_fraction_t is read; it is decreased by the number of character effectively used.
allow_empty	Whether this function is allowed to read 0 characters; if set to false this function raises a parse_exception if it cannot read at least one valid character. Default is false
value_if_empty	Value returned if no character was consumes and allow_empty is true. Default is 1.

Returns

The parsed q_fraction_t.

lr_parse_sign()

char awali::sttc::internal::lr_parse_sign	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = true,
		char	value_if_empty = '\0'
	)

lr_parse_uint()

unsigned awali::sttc::internal::lr_parse_uint	(	std::string const &	s,
		size_t &	p,
		bool	allow_empty = false,
		unsigned	value_if_empty = 0
	)

Reads an unsigned int written in decimal left of position p in string s, by using as many character as possible Parameter p is decreased by the number of characters thus consumed.

Parameters

s	String in which the uint is read
p	Position left of which the uint is read ; decreased by the number of character effectively used.
allow_empty	Whether this function is allowed to read 0 characters; if set to false this function raises a parse_exception if it cannot read at least one valid character.
value_if_empty	value returned if no characters and allow_empty is true.

Returns

the parsed uint

lr_scan_complex()

unsigned awali::sttc::internal::lr_scan_complex	(	std::string const &	s,
		size_t &	pp
	)

lr_scan_digits()

unsigned awali::sttc::internal::lr_scan_digits	(	std::string const &	s,
		size_t &	p
	)

Scans for as many [0-9] digits as possible, left of position p in string s.

Parameter p is decreased by the amount of character scanned.

Parameters

s	String to scan
p	Position left of which the scan starts.

Returns

the number of digits found (might be 0).

lr_scan_dot()

unsigned awali::sttc::internal::lr_scan_dot	(	std::string const &	s,
		size_t &	p
	)

lr_scan_double()

unsigned awali::sttc::internal::lr_scan_double	(	std::string const &	s,
		size_t &	pp
	)

lr_scan_e()

unsigned awali::sttc::internal::lr_scan_e	(	std::string const &	s,
		size_t &	p
	)

lr_scan_int()

unsigned awali::sttc::internal::lr_scan_int	(	std::string const &	s,
		size_t &	p
	)

lr_scan_one()

unsigned awali::sttc::internal::lr_scan_one	(	std::string const &	s,
		size_t &	p,
		char const *	t
	)

Scans for a character in t left of position p in s.

Returns 1 if both (p-1) is nonnegative and s[p-1] is in c-string t; or returns 0 otherwise. Parameter p is modified accordingly.

Returns

the number of characters scanned (0 or 1)

lr_scan_sign()

unsigned awali::sttc::internal::lr_scan_sign	(	std::string const &	s,
		size_t &	p
	)

make_random_selector()

template<typename RandomGenerator = std::default_random_engine>

struct random_selector< RandomGenerator > awali::sttc::internal::make_random_selector

(

const RandomGenerator &

g

)

make_word_context()

template<typename LabelSet , typename WeightSet >

word_context_t<context<LabelSet, WeightSet> > awali::sttc::internal::make_word_context

(

const context< LabelSet, WeightSet > &

ctx

)

The wordset context of a labelset.

make_word_polynomialset()

template<typename Ctx >

auto awali::sttc::internal::make_word_polynomialset

(

const Ctx &

ctx

)

-> word_polynomialset_t<Ctx>

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

make_wordset()

template<typename LabelSet >

law_t<LabelSet> awali::sttc::internal::make_wordset

(

const LabelSet &

ls

)

The wordset of a labelset.

num_deterministic_states()

template<class Aut >

size_t awali::sttc::internal::num_deterministic_states

(

const Aut &

aut

)

Number of non-deterministic states.

powten()

static unsigned awali::sttc::internal::powten ( unsigned  i )

static

print() [1/2]

template<typename T >

std::ostream& awali::sttc::internal::print	(	const std::set< T > &	set,
		std::ostream &	o
	)

print() [2/2]

template<typename T , typename Compare , typename Alloc >

std::ostream& awali::sttc::internal::print	(	const std::set< T, Compare, Alloc > &	set,
		std::ostream &	o
	)

Print with a separator. Meant to help debugging.

random()

template<typename Ctx >

mutable_automaton<Ctx> awali::sttc::internal::random	(	const Ctx &	ctx,
		unsigned	num_states,
		float	density = 0.1,
		unsigned	num_initial = 1,
		unsigned	num_final = 1
	)

random_deterministic()

template<typename Ctx >

mutable_automaton<Ctx> awali::sttc::internal::random_deterministic	(	const Ctx &	ctx,
		unsigned	num_states
	)

random_label() [1/6]

template<typename LabelSet , typename RandomGenerator = std::default_random_engine>

LabelSet::value_t awali::sttc::internal::random_label	(	const LabelSet &	ls,
		RandomGenerator &	gen = RandomGenerator()
	)

random_label() [2/6]

template<typename LabelSet , typename RandomGenerator = std::default_random_engine>

nullableset<LabelSet>::value_t awali::sttc::internal::random_label	(	const nullableset< LabelSet > &	ls,
		RandomGenerator &	gen = RandomGenerator()
	)

random_label() [3/6]

template<typename RandomGenerator = std::default_random_engine>

oneset::value_t awali::sttc::internal::random_label	(	const oneset &	ls,
		RandomGenerator &	= RandomGenerator()
	)

random_label() [4/6]

template<typename Context , typename RandomGenerator = std::default_random_engine>

ratexpset<Context>::value_t awali::sttc::internal::random_label	(	const ratexpset< Context > &	rs,
		RandomGenerator &	gen = RandomGenerator()
	)

random_label() [5/6]

template<typename... LabelSet, size_t... I, typename RandomGenerator = std::default_random_engine>

tupleset<LabelSet...>::value_t awali::sttc::internal::random_label	(	const tupleset< LabelSet... > &	ls,
		RandomGenerator &	gen,
		awali::internal::index_sequence< I... >
	)

random_label() [6/6]

template<typename... LabelSet, typename RandomGenerator = std::default_random_engine>

tupleset<LabelSet...>::value_t awali::sttc::internal::random_label	(	const tupleset< LabelSet... > &	ls,
		RandomGenerator &	gen = RandomGenerator()
	)

star_here() [1/2]

template<typename Aut , typename P >

Aut& awali::sttc::internal::star_here	(	Aut &	res,
		priority::ONE< P >
	)

In place star of an automaton.

star_here() [2/2]

template<typename Aut , typename P >

auto awali::sttc::internal::star_here	(	Aut &	res,
		priority::TWO< P >
	)		-> typename std::enable_if<labelset_t_of<Aut>::has_one(),Aut&>::type

subset()

template<typename Container1 , typename Container2 >

bool awali::sttc::internal::subset	(	const Container1 &	set1,
		const Container2 &	set2
	)

Whether set1 ⊆ set2.

sum_of_standard_here()

template<typename A , typename B >

A& awali::sttc::internal::sum_of_standard_here	(	A &	res,
		const B &	b
	)

Merge transitions of b into those of res.

Precondition

The context of res must include that of b.

res and b must be standard.

to_vector()

template<typename Cont >

std::vector<typename Cont::value_type> awali::sttc::internal::to_vector

(

const Cont &

cont

)

Return the content of cont as a vector.

tuple_tail()

template<typename Tuple >

auto awali::sttc::internal::tuple_tail

(

const Tuple &

t

)

-> typename tail_tuple<Tuple>::type

unnormalized_lift()

template<typename Aut >

internal::lifted_automaton_t<Aut> awali::sttc::internal::unnormalized_lift	(	const Aut &	a,
		bool	keep_history = true
	)

variadic_mul() [1/2]

template<typename WS , typename W1 , typename... W>

auto awali::sttc::internal::variadic_mul	(	const WS &	weightset,
		const W1 &	w1,
		const W &...	w
	)		-> typename WS::value_t

variadic_mul() [2/2]

template<typename WS , typename W1 , typename W2 >

auto awali::sttc::internal::variadic_mul	(	const WS &	weightset,
		const W1 &	w1,
		const W2 &	w2
	)		-> typename WS::value_t

zip()

template<typename... Sequences>

zip_sequences<Sequences...> awali::sttc::internal::zip

(

Sequences &&...

seqs

)

zip_map_tuple()

template<typename Dereference = as_pair, typename... Maps>

zipped_maps<Dereference, Maps...> awali::sttc::internal::zip_map_tuple

(

const std::tuple< Maps... > &

maps

)

zip_maps()

template<typename Dereference = as_pair, typename... Maps>

zipped_maps<Dereference, Maps...> awali::sttc::internal::zip_maps

(

Maps &&...

maps

)

zip_tuple()

template<typename... Sequences>

zip_sequences<Sequences...> awali::sttc::internal::zip_tuple

(

const std::tuple< Sequences... > &

seqs

)