Awali
Another Weighted Automata library
Data Structures | Typedefs | Functions
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 > 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 >
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 &ws, priority::ONE< P >)
 
template<typename WS , typename P >
constexpr auto is_finite (const WS &ws, priority::TWO< P >) -> typename WS::finite_t
 
template<typename WS , typename P >
constexpr bool is_locally_finite (const WS &ws, priority::ONE< P >)
 
template<typename WS , typename P >
constexpr auto is_locally_finite (const WS &ws, priority::TWO< P >) -> typename WS::locally_finite_t
 
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<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 set1set2. 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 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

◆ 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 >  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,
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,
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 &  ws,
priority::ONE< P >   
)
constexpr

◆ is_finite() [2/2]

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

◆ is_locally_finite() [1/2]

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

◆ is_locally_finite() [2/2]

template<typename WS , typename P >
constexpr auto awali::sttc::internal::is_locally_finite ( const WS &  ws,
priority::TWO< P >   
) -> typename WS::locally_finite_t
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/2]

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_() [2/2]

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
sString in which the complex number is read.
pPosition left of which the complex number is read; it is decreased by the number of character effectively used.
allow_emptyWhether 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_emptyValue 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
sString in which the double is read.
pPosition left of which the double is read; it is decreased by the number of character effectively used.
allow_emptyWhether 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_emptyValue 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
sString in which the int is read
pPosition left of which the int is read; decreased by the number of character effectively used.
allow_emptyWhether 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_emptyValue 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
sString in which the q_fraction_t is read.
pPosition left of which the q_fraction_t is read; it is decreased by the number of character effectively used.
allow_emptyWhether 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_emptyValue 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
sString in which the uint is read
pPosition left of which the uint is read ; decreased by the number of character effectively used.
allow_emptyWhether 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_emptyvalue 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
sString to scan
pPosition 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 set1set2.

◆ 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

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