Classes | |
| struct | AlphabetSetBase |
| Base class for structural elements of alphabets. More... | |
| struct | alphabet_traits |
| Trait for virtual types of structural elements for alphabets. More... | |
| struct | FreeMonoidBase |
| Structural element for free monoid. More... | |
| struct | FreeMonoidProduct |
| Implementation of a monoid which is a product of two free monoids. More... | |
| struct | FreeMonoidProductBase |
| Structural element for free monoid product. More... | |
| struct | letter_traits |
| struct | token_representation |
| struct | MonoidBase |
The base class of all structures that are monoids. More... | |
| struct | identity_as |
| struct | zero_as |
| struct | word_traits |
| Trait for virtual types of structural elements for words. More... | |
| struct | NumericalSemiring |
| The set of semirings implemented with usual operations (+, *). More... | |
| struct | mul_kind |
| Empty class used as static information to denote the kind of internal operation of a semigroup. More... | |
| struct | add_kind |
| Empty class used as static information to denote the kind of internal operation of a semigroup. More... | |
| struct | SemigroupBase |
| Base class of all structures that are semigroups. More... | |
| struct | SemiringBase |
| Base class for all structures that are semirings. More... | |
| struct | SeriesBase |
| Structural element of series K<A*> from a free monoid A* to a semiring K. More... | |
| struct | series_traits |
| Meta information about series. More... | |
| struct | mute_series_impl |
| struct | mute_series_traits |
| struct | TropicalMin |
| Static information about the kind of tropical we are confronted with. More... | |
| struct | TropicalMax |
| Static information about the kind of tropical we are confronted with. More... | |
| struct | TropicalSemiring |
| Structural element that denotes tropical semiring. More... | |
| struct | AlphabetSet |
| Static implementation of alphabet structural element. More... | |
| class | AlphabetDecorator |
| Decorate a given alphabet implementation with meta-symbols. More... | |
| struct | alphabet_traits< AlphabetSet< L >, AlphabetDecorator< L, T > > |
| Meta information about the mixing of AlphabetSet with AlphabetDecorator. More... | |
| struct | list_or_string |
| struct | list_or_string< char > |
| struct | list_or_string< wchar_t > |
| struct | FreeMonoid |
| Implementation of a free monoid which aggregates its alphabet. More... | |
| struct | letter_traits< char > |
| struct | letter_traits< int > |
| class | static_ranged |
| struct | static_char_interval |
| struct | letter_traits< static_ranged< T, Interval > > |
| class | RationalNumber |
| Rational numbers class. More... | |
| class | CoefficientEval |
| class | ExpConvertVisitor |
| struct | Lexer |
| struct | BinaryOp |
| BinaryOp is integrated in the pattern matching system to permit a factorization of the accessors. More... | |
| struct | UnaryOp |
| UnaryOp is integrated in the pattern matching system to permit a factorization of the accessors. More... | |
| struct | Value |
| Value is integrated into the pattern matching system to permit a factorization of the accessors. More... | |
| struct | GenericMatcher |
| GenericMatcher manages the dispatch of pattern matching. More... | |
| struct | KRatExpMatcher |
| struct | KRatExpIdentity |
| interface | semiring_virtual |
| Virtual pure class used by bison to deal with vaucanson's templated structures. More... | |
| interface | krat_exp_virtual |
| Virtual pure class used by bison to deal with vaucanson's templated structures. More... | |
| struct | krat_exp_proxy |
| Proxy over Vaucanson Element. More... | |
| struct | semiring_proxy |
| Proxy over Vaucanson Semiring. More... | |
| struct | KRatExpTranspose |
| class | polynom |
| struct | series_traits< polynom< Tm, Tw > > |
| struct | mute_series_impl< polynom< Tm, Tw >, W, M > |
| struct | DefaultTransposeFun< Series, polynom< Tm, Tw > > |
| class | DispatchVisitor |
| struct | semiring_slot_tag |
| struct | monoid_slot_tag |
| struct | Series |
| This is the final class for series. More... | |
| struct | mute_series_traits< Series< W, M >, NewW, NewM > |
| struct | DefaultTransposeFun |
| struct | KRatExpCDerivation |
| struct | pseudo_exp_list |
| struct | KRatExpExpander |
| struct | KRatExpPartialDerivation |
| class | KRatExpIsRealtime |
| struct | KRatExpRealtime |
| class | Standard_OfVisitor |
| struct | alphabet_traits< AlphabetSet< L >, std::set< L > > |
| Meta information about the mixing of AlphabetSet with std::set. More... | |
| struct | list_or_string< std::pair< A, B > > |
| struct | letter_traits< std::pair< U, V > > |
| struct | series_traits< rat::exp< Tm, Tw > > |
| struct | mute_series_impl< rat::exp< Tm, Tw >, W, M > |
| struct | DispatchFunction< rat::exp< M, W > > |
| Classical dispatch function for rat::exp. More... | |
| struct | DefaultTransposeFun< S, rat::exp< Word, Weight > > |
| struct | word_traits< FreeMonoid< A >, std::basic_string< typename A::letter_t > > |
| Meta information about the mixing of FreeMonoid with std::basic_string. More... | |
Namespaces | |
| namespace | small_alpha_letter |
| namespace | char_letter |
| namespace | char_pair |
| namespace | weighted_letter |
| namespace | int_letter |
Typedefs | |
|
typedef token_representation< misc::true_t > | token_representation_t |
Functions | |
| template<typename S, typename St, typename T> | |
| St & | op_rout (const algebra::AlphabetSetBase< S > &s, St &st, const T &a) |
| Implementation of generic stream output operator for alphabets. | |
| template<typename S, typename T, typename L> | |
| bool | op_letter_equality (const algebra::AlphabetSetBase< S > &s, const T &a, L lhs, L rhs) |
| Implementation of generic letter equality modulo meta-characters. | |
| template<typename S, typename T, typename CharContainer> | |
| bool | op_parse (const algebra::FreeMonoidBase< S > &s, T &v, const std::string &, typename std::string::const_iterator &, const CharContainer &escaped) |
| template<typename Self, typename T> | |
| void | op_in_mirror (const algebra::FreeMonoidBase< Self > &s, T &v) |
| template<typename Self, typename T> | |
| bool | op_contains (const algebra::FreeMonoidBase< Self > &s, const T &v) |
| template<typename Self, typename St, typename T> | |
| St & | op_rout (const algebra::FreeMonoidBase< Self > &s, St &st, const T &v) |
| template<class F, class S> | |
| bool | operator== (const FreeMonoidProduct< F, S > &m1, const FreeMonoidProduct< F, S > &m2) |
| template<typename T, typename Self> | |
| T | op_default (SELECTOR(algebra::MonoidBase< Self >), SELECTOR(T)) |
| template<typename S, typename T> | |
| bool | op_can_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
Whether a non-starable Element can be chosen from a Semiring. | |
| template<typename S, typename T> | |
| Element< S, T > | op_choose_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
| A random starable element in the set. | |
| template<typename S, typename T> | |
| Element< S, T > | op_choose_non_starable (const algebra::SemiringBase< S > &set, SELECTOR(T)) |
| A random non-starable element in the set. | |
| template<typename S, typename T> | |
| bool | op_parse (const algebra::SemiringBase< S > &, T &w, const std::string &, typename std::string::const_iterator &) |
| template<typename Self, typename T> | |
| bool | op_starable (const algebra::SemiringBase< Self > &s, const T &v) |
| template<typename Self, typename T> | |
| void | op_in_star (const algebra::SemiringBase< Self > &s, T &v) |
| template<typename Self, typename T> | |
| T | op_default (SELECTOR(algebra::SemiringBase< Self >), SELECTOR(T)) |
| template<typename S, typename T> | |
| bool | op_is_finite_app (const algebra::SeriesBase< S > &s, const T &t) |
| template<class S, class T> | |
| Element< S, T > | op_series_choose (const algebra::SeriesBase< S > &s, SELECTOR(T)) |
| template<class S, class T> | |
| algebra::series_traits< T >::support_t | op_support (const algebra::SeriesBase< S > &, const T &v) |
| template<class S, class M> | |
| S | op_convert (const algebra::SeriesBase< S > &, const algebra::FreeMonoidBase< M > &) |
| template<class S, class T> | |
| T | op_convert (const algebra::SeriesBase< S > &s, SELECTOR(T), const T &src_) |
| template<typename S, typename T, typename M, typename W> | |
| void | op_series_structure (const algebra::SeriesBase< S > &s, const T &t, const W &w) |
| template<class S, class T, class U> | |
| T | op_convert (const algebra::SeriesBase< S > &s, SELECTOR(T), const U &src_) |
| template<typename L> | |
| size_t | op_max_size (const algebra::AlphabetSet< L > &, const std::set< L > &) |
| template<typename L> | |
| bool | op_contains (const algebra::AlphabetSet< L > &s, const std::set< L > &a) |
| template<typename L> | |
| bool | op_is_finite (const algebra::AlphabetSet< L > &s, const std::set< L > &a) |
| template<typename L> | |
| bool | op_contains_e (const algebra::AlphabetSet< L > &s, const std::set< L > &a, const L &v) |
| template<typename L, typename T> | |
| bool | op_contains (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a) |
| template<typename L, typename T> | |
| bool | op_is_finite (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a) |
| template<typename L, typename T> | |
| bool | op_contains_e (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a, const L &v) |
| template<typename T, typename L> | |
| bool | op_letter_equality (const algebra::AlphabetSet< L > &s, const algebra::AlphabetDecorator< L, T > &a, L lhs, L rhs) |
| template<typename A> | |
| void | op_in_mul (const algebra::FreeMonoid< A > &s, std::basic_string< typename A::letter_t > &dst, const std::basic_string< typename A::letter_t > &src) |
| template<typename A> | |
| std::basic_string< typename A::letter_t > | op_mul (const algebra::FreeMonoid< A > &s, const std::basic_string< typename A::letter_t > &a, const std::basic_string< typename A::letter_t > &b) |
| template<typename A> | |
| std::basic_string< typename A::letter_t > | op_convert (SELECTOR(algebra::FreeMonoid< A >), SELECTOR(std::basic_string< typename A::letter_t >), const typename A::letter_t &c) |
| template<typename A> | |
| std::basic_string< typename A::letter_t > | op_convert (SELECTOR(algebra::FreeMonoid< A >), SELECTOR(std::basic_string< typename A::letter_t >), const std::string &c) |
| template<typename A> | |
| std::basic_string< typename A::letter_t > | op_convert (SELECTOR(algebra::FreeMonoid< A >), SELECTOR(std::basic_string< typename A::letter_t >), const char *c) |
| template<typename A> | |
| bool | op_xeq (const algebra::FreeMonoid< A > &s, const std::basic_string< typename A::letter_t > &a, const std::basic_string< typename A::letter_t > &b) |
| template<typename A> | |
| const std::basic_string< typename A::letter_t, misc::char_traits< typename A::letter_t > > & | identity_value (SELECTOR(algebra::FreeMonoid< A >), SELECTOR2(std::basic_string< typename A::letter_t, misc::char_traits< typename A::letter_t > >)) |
| template<class A> | |
| Element< algebra::FreeMonoid< A >, std::basic_string< typename A::letter_t > > | op_choose (const algebra::FreeMonoid< A > &s, SELECTOR(std::basic_string< typename A::letter_t >)) |
| template<typename A> | |
| std::list< typename A::letter_t > | op_convert (SELECTOR(algebra::FreeMonoidBase< A >), SELECTOR(std::list< typename A::letter_t >), const typename A::letter_t &c) |
| template<typename A> | |
| void | op_in_mul (const algebra::FreeMonoidBase< A > &s, std::list< typename A::letter_t > &dst, const std::list< typename A::letter_t > &src) |
| template<typename A> | |
| std::list< typename A::letter_t > | op_mul (const algebra::FreeMonoidBase< A > &s, const std::list< typename A::letter_t > &a, const std::list< typename A::letter_t > &b) |
| template<typename A> | |
| bool | operator== (const FreeMonoid< A > &a, const FreeMonoid< A > &b) |
| template<class Self, typename T> | |
| MetaElement< algebra::FreeMonoidProductBase< Self >, T >::first_monoid_elt_t | op_first (const algebra::FreeMonoidProductBase< Self > &s, T &v) |
| template<class Self, typename T> | |
| MetaElement< algebra::FreeMonoidProductBase< Self >, T >::second_monoid_elt_t | op_second (const algebra::FreeMonoidProductBase< Self > &s, T &v) |
| template<class F, class S> | |
| void | op_in_mul (const algebra::FreeMonoidProduct< F, S > &s, std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &dst, const std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &src) |
| template<class F, class S> | |
| std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > | op_mul (const algebra::FreeMonoidProduct< F, S > &s, const std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &a, const std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > &b) |
| template<class F, class S> | |
| Element< algebra::FreeMonoidProduct< F, S >, std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > > > | op_choose (const algebra::FreeMonoidProduct< F, S > &s, SELECTOR2(std::pair< std::basic_string< typename F::letter_t >, std::basic_string< typename S::letter_t > >)) |
| template<typename Self, typename T> | |
| void | op_in_mirror (const algebra::FreeMonoidProductBase< Self > &s, T &v) |
| template<typename Self, typename T, typename Ftor> | |
| Ftor::result_type | op_length (const algebra::FreeMonoidProductBase< Self > &, const T &v, Ftor f) |
| template<typename Self, typename St, typename T> | |
| St & | op_rout (const algebra::FreeMonoidProductBase< Self > &s, St &st, const T &v) |
| template<typename S, typename CharContainer> | |
| bool | op_parse (const algebra::FreeMonoidBase< S > &set, std::basic_string< char > &v, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped) |
| template<typename S, typename U, typename V, typename CharContainer> | |
| bool | op_parse (const algebra::FreeMonoidBase< S > &set, std::basic_string< std::pair< U, V > > &v, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped) |
| template<typename S, typename CharContainer> | |
| bool | op_parse (const algebra::FreeMonoidBase< S > &set, std::basic_string< int > &v, const std::string &s, typename std::string::const_iterator &i, const CharContainer &escaped) |
| template<class T, class Interval> | |
| bool | operator< (const static_ranged< T, Interval > &lhs, const static_ranged< T, Interval > &rhs) |
| template<class T, class Interval> | |
| bool | operator== (const static_ranged< T, Interval > &lhs, const static_ranged< T, Interval > &rhs) |
| template<class Stream, class T, class Interval> | |
| Stream & | operator<< (Stream &s, static_ranged< T, Interval > &sr) |
| template<typename T> | |
| bool | op_contains (const algebra::NumericalSemiring &s, T c) |
| template<typename T, typename U> | |
| void | op_in_mul (const algebra::NumericalSemiring &s1, T &dst, U arg) |
| template<typename T, typename U> | |
| void | op_in_add (const algebra::NumericalSemiring &s1, T &dst, U arg) |
| template<typename T, typename U> | |
| T | op_mul (const algebra::NumericalSemiring &s, T a, U b) |
| template<typename T, typename U> | |
| T | op_add (const algebra::NumericalSemiring &s, T a, U b) |
| template<class T> | |
| Element< algebra::NumericalSemiring, T > | op_choose (const algebra::NumericalSemiring &s, SELECTOR(T)) |
| bool | op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(int)) |
|
Element< algebra::NumericalSemiring, int > | op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(int)) |
|
Element< algebra::NumericalSemiring, int > | op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(int)) |
| template<typename T> | |
| void | op_in_mul (const algebra::NumericalSemiring &s1, bool &dst, bool src) |
| bool | op_mul (const algebra::NumericalSemiring &s, bool a, bool b) |
| void | op_in_add (const algebra::NumericalSemiring &s1, bool &dst, bool src) |
| bool | op_add (const algebra::NumericalSemiring &s, bool a, bool b) |
| bool | op_starable (const algebra::NumericalSemiring &s, bool b) |
| void | op_in_star (const algebra::NumericalSemiring &s, bool &b) |
|
Element< algebra::NumericalSemiring, bool > | op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(bool)) |
|
Element< algebra::NumericalSemiring, bool > | op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(bool)) |
| template<typename T> | |
| bool | op_starable (const algebra::NumericalSemiring &s, T v) |
| bool | op_starable (const algebra::NumericalSemiring &s, const float &f) |
| bool | op_starable (const algebra::NumericalSemiring &s, const double &f) |
| void | op_in_star (const algebra::NumericalSemiring &s, float &f) |
| void | op_in_star (const algebra::NumericalSemiring &s, double &f) |
| bool | op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(float)) |
|
Element< algebra::NumericalSemiring, float > | op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(float)) |
|
Element< algebra::NumericalSemiring, float > | op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(float)) |
| bool | op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(double)) |
|
Element< algebra::NumericalSemiring, double > | op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(double)) |
|
Element< algebra::NumericalSemiring, double > | op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(double)) |
| bool | op_starable (const algebra::NumericalSemiring &s, const algebra::RationalNumber &r) |
| void | op_in_star (const algebra::NumericalSemiring &s, algebra::RationalNumber &r) |
| bool | op_can_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(algebra::RationalNumber)) |
|
Element< algebra::NumericalSemiring, algebra::RationalNumber > | op_choose_starable (const algebra::NumericalSemiring &set, SELECTOR(algebra::RationalNumber)) |
|
Element< algebra::NumericalSemiring, algebra::RationalNumber > | op_choose_non_starable (const algebra::NumericalSemiring &set, SELECTOR(algebra::RationalNumber)) |
| template<class T> | |
| bool | operator< (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| bool | operator< (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| bool | operator<= (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| bool | operator<= (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| bool | operator> (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| bool | operator> (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| bool | operator>= (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| bool | operator>= (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| bool | operator== (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| bool | operator== (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| bool | operator!= (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| bool | operator!= (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| RationalNumber | operator+ (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber | operator+ (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| RationalNumber | operator- (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber | operator- (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| RationalNumber | operator * (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber | operator * (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| RationalNumber | operator/ (const RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber | operator/ (const T nb2, const RationalNumber &nb) |
| template<class T> | |
| RationalNumber & | operator+= (RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber & | operator-= (RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber & | operator *= (RationalNumber &nb, const T nb2) |
| template<class T> | |
| RationalNumber & | operator/= (RationalNumber &nb, const T nb2) |
| std::ostream & | operator<< (std::ostream &ostr, const RationalNumber &nb) |
| int | gcd (int a, unsigned int b) |
| int | lcm (int a, unsigned int b) |
| template<class TropicalKind, typename T> | |
| bool | op_contains (const algebra::TropicalSemiring< TropicalKind > &s, T c) |
| template<class TropicalKind, typename T, typename U> | |
| void | op_in_mul (const algebra::TropicalSemiring< TropicalKind > &s1, T &dst, U arg) |
| template<class TropicalKind, typename T, typename U> | |
| T | op_mul (const algebra::TropicalSemiring< TropicalKind > &s, T a, U b) |
| template<typename T, typename U> | |
| void | op_in_add (const algebra::TropicalSemiring< algebra::TropicalMax > &s1, T &dst, U arg) |
| template<typename T, typename U> | |
| void | op_in_add (const algebra::TropicalSemiring< algebra::TropicalMin > &s1, T &dst, U arg) |
| template<typename T, typename U> | |
| T | op_add (const algebra::TropicalSemiring< algebra::TropicalMax > &s, T a, U b) |
| template<typename T, typename U> | |
| T | op_add (const algebra::TropicalSemiring< algebra::TropicalMin > &s, T a, U b) |
| template<typename T> | |
| bool | op_starable (const algebra::TropicalSemiring< algebra::TropicalMin > &, T b) |
| template<class T> | |
| void | op_in_star (const algebra::TropicalSemiring< algebra::TropicalMin > &s, T &b) |
| template<typename T> | |
| bool | op_starable (const algebra::TropicalSemiring< algebra::TropicalMax > &, T b) |
| template<class T> | |
| void | op_in_star (const algebra::TropicalSemiring< algebra::TropicalMax > &, T &b) |
| template<class TropicalKind, class T> | |
| Element< algebra::TropicalSemiring< TropicalKind >, T > | op_choose (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T)) |
| template<class TropicalKind, typename T> | |
| bool | op_can_choose_non_starable (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T)) |
| template<class TropicalKind, typename T> | |
| Element< algebra::TropicalSemiring< TropicalKind >, T > | op_choose_starable (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T)) |
| template<class TropicalKind, typename T> | |
| Element< algebra::TropicalSemiring< TropicalKind >, T > | op_choose_non_starable (const algebra::TropicalSemiring< TropicalKind > &set, SELECTOR(T)) |
| template<typename St, typename T> | |
| St & | op_rout (const algebra::TropicalSemiring< algebra::TropicalMax > &s, St &st, const T &v) |
| template<typename St, typename T> | |
| St & | op_rout (const algebra::TropicalSemiring< algebra::TropicalMin > &s, St &st, const T &v) |
| template<> | |
| float | zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMax >), SELECTOR(float)) |
| template<> | |
| double | zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMax >), SELECTOR(double)) |
| template<> | |
| float | zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMin >), SELECTOR(float)) |
| template<> | |
| double | zero_value (SELECTOR(algebra::TropicalSemiring< algebra::TropicalMin >), SELECTOR(double)) |
| template<> | |
| bool | op_starable (const algebra::TropicalSemiring< algebra::TropicalMin > &, bool) |
| template<> | |
| void | op_in_star (const algebra::TropicalSemiring< algebra::TropicalMin > &, bool &b) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_convert (const algebra::Series< W, M > &s1, SELECTOR2(rat::exp< Tm, Tw >), const algebra::Series< W, M > &s2, const algebra::polynom< Tm, Tw > &p_value) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| bool | op_contains (const algebra::Series< W, M > &, const rat::exp< Tm, Tw > &) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| bool | op_is_finite_app (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| Tm | op_choose_from_supp (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_add (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst, const rat::exp< Tm, Tw > &arg) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_mul (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &a, const rat::exp< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_mul (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst, const rat::exp< Tm, Tw > &arg) |
| template<typename Tm, typename Tw, typename M, typename W> | |
| rat::exp< Tm, Tw > | op_convert (SELECTOR2(algebra::Series< M, W >), SELECTOR2(rat::exp< Tm, Tw >), const Tm &m_value) |
| template<typename Tm, typename Tw, typename M, typename W> | |
| rat::exp< Tm, Tw > | op_convert (SELECTOR2(algebra::Series< M, W >), SELECTOR2(rat::exp< Tm, Tw >), char m_value) |
| template<typename Tm, typename Tw, typename W, typename M, typename oTm> | |
| rat::exp< Tm, Tw > | op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >), SELECTOR(M), const oTm &m_value) |
| template<typename Tm, typename Tw, typename W, typename M, typename oTw> | |
| rat::exp< Tm, Tw > | op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >), SELECTOR(W), const oTw &w_value) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| void | op_assign (const algebra::Series< W, M > &s, const M &monoid, rat::exp< Tm, Tw > &dst, const oTm &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| void | op_assign (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &dst, const oTw &src) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| bool | op_starable (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &dst) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_star (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_star (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| void | op_in_add (const algebra::Series< W, M > &s, const M &monoid, rat::exp< Tm, Tw > &dst, const oTm &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| rat::exp< Tm, Tw > | op_add (const algebra::Series< W, M > &s, const M &monoid, const rat::exp< Tm, Tw > &a, const oTm &b) |
| template<typename M, typename W, typename oTm, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_add (const M &monoid, const algebra::Series< W, M > &s, const oTm &a, const rat::exp< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| void | op_in_add (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &dst, const oTw &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| rat::exp< Tm, Tw > | op_add (const algebra::Series< W, M > &s, const W &semiring, const rat::exp< Tm, Tw > &a, const oTw &b) |
| template<typename W, typename M, typename oTw, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_add (const W &semiring, const algebra::Series< W, M > &s, const oTw &a, const rat::exp< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| void | op_in_mul (const algebra::Series< W, M > &s, const W &semiring, rat::exp< Tm, Tw > &ret, const oTw &w) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| rat::exp< Tm, Tw > | op_mul (const algebra::Series< W, M > &s, const W &semiring, const rat::exp< Tm, Tw > &a, const oTw &w) |
| template<typename W, typename M, typename oTw, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_mul (const W &semiring, const algebra::Series< W, M > &s, const oTw &w, const rat::exp< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| Tw | op_series_get (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &p, const oTm &m) |
| template<class W, class M, class Tm, class Tw> | |
| Element< algebra::Series< W, M >, rat::exp< Tm, Tw > > | op_choose (const algebra::Series< W, M > &s, SELECTOR2(rat::exp< Tm, Tw >)) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_transpose (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &dst) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| algebra::series_traits< rat::exp< Tm, Tw > >::support_t | op_support (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| rat::exp< Tm, Tw > | op_add (const algebra::Series< W, M > &s, const rat::exp< Tm, Tw > &a, const rat::exp< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm, typename oTw> | |
| void | op_series_set (const algebra::Series< W, M > &s, rat::exp< Tm, Tw > &p, const oTm &m, const oTw &w) |
| template<class Series, class T> | |
| std::pair< typename Element< Series, T >::semiring_elt_t, Element< Series, T > > | coefficient (const Element< Series, T > &exp) |
| template<typename Tm, typename Tw, typename W, typename M, typename oTm, typename oTw> | |
| rat::exp< Tm, Tw > | convert_exp (SELECTOR2(rat::exp< Tm, Tw >), const Series< W, M > &s, const rat::exp< oTm, oTw > &arg) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm, typename oTw> | |
| Element< Series< W, M >, rat::exp< Tm, Tw > > | convert_exp (SELECTOR4(Element< Series< W, M >, rat::exp< Tm, Tw > >), const Element< Series< W, M >, rat::exp< oTm, oTw > > &arg) |
| template<class S, class T> | |
| std::pair< bool, std::string > | parse (const std::string &from, Element< S, T > &exp, const token_representation< typename S::monoid_t::letter_t > tok_rep=token_representation< typename S::monoid_t::letter_t >(), bool lex_trace=false, bool parse_trace=false) |
| Parse a rational expression. | |
| template<class Tm, class Tw> | |
| bool | operator== (const polynom< Tm, Tw > &lhs, const polynom< Tm, Tw > &rhs) |
| template<class Tm, class Tw> | |
| bool | operator!= (const polynom< Tm, Tw > &lhs, const polynom< Tm, Tw > &rhs) |
| template<class Tm, class Tw> | |
| bool | operator< (const polynom< Tm, Tw > &lhs, const polynom< Tm, Tw > &rhs) |
| template<class Tm, class Tw> | |
| bool | operator> (const polynom< Tm, Tw > &lhs, const polynom< Tm, Tw > &rhs) |
| template<class Tm, class Tw> | |
| bool | operator<= (const polynom< Tm, Tw > &lhs, const polynom< Tm, Tw > &rhs) |
| template<class Tm, class Tw> | |
| bool | operator>= (const polynom< Tm, Tw > &lhs, const polynom< Tm, Tw > &rhs) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| bool | op_contains (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &m) |
| template<typename Self, typename Tm, typename Tw> | |
| void | op_in_star (const algebra::SeriesBase< Self > &s, algebra::polynom< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| bool | op_is_finite_app (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_add (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &dst, const algebra::polynom< Tm, Tw > &arg) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| algebra::polynom< Tm, Tw > | op_add (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &a, const algebra::polynom< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| algebra::polynom< Tm, Tw > | op_mul (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &a, const algebra::polynom< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_mul (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &dst, const algebra::polynom< Tm, Tw > &arg) |
| template<typename Tm, typename Tw, typename W, typename M> | |
| algebra::polynom< Tm, Tw > | op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >), const Tm &m_value) |
| template<typename Tm, typename Tw, typename W, typename M, typename oTw> | |
| algebra::polynom< Tm, Tw > | op_convert (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >), SELECTOR(algebra::SemiringBase< W >), const oTw &w_value) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| void | op_assign (const algebra::Series< W, M > &s, const algebra::MonoidBase< M > &monoid, algebra::polynom< Tm, Tw > &dst, const oTm &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| void | op_assign (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, algebra::polynom< Tm, Tw > &dst, const oTw &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| void | op_in_add (const algebra::Series< W, M > &s, const algebra::MonoidBase< M > &monoid, algebra::polynom< Tm, Tw > &dst, const oTm &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| algebra::polynom< Tm, Tw > | op_add (const algebra::Series< W, M > &s, const algebra::MonoidBase< M > &monoid, const algebra::polynom< Tm, Tw > &a, const oTm &b) |
| template<typename M, typename W, typename oTm, typename Tm, typename Tw> | |
| algebra::polynom< Tm, Tw > | op_add (const algebra::MonoidBase< M > &monoid, const algebra::Series< W, M > &s, const oTm &a, const algebra::polynom< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| void | op_in_add (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, algebra::polynom< Tm, Tw > &dst, const oTw &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| algebra::polynom< Tm, Tw > | op_add (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, const algebra::polynom< Tm, Tw > &a, const oTw &b) |
| template<typename W, typename M, typename oTw, typename Tm, typename Tw> | |
| algebra::polynom< Tm, Tw > | op_add (const algebra::SemiringBase< W > &semiring, const algebra::Series< W, M > &s, const oTw &a, const algebra::polynom< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| void | op_in_mul (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, algebra::polynom< Tm, Tw > &dst, const oTw &src) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTw> | |
| algebra::polynom< Tm, Tw > | op_mul (const algebra::Series< W, M > &s, const algebra::SemiringBase< W > &semiring, const algebra::polynom< Tm, Tw > &a, const oTw &b) |
| template<typename W, typename M, typename oTw, typename Tm, typename Tw> | |
| algebra::polynom< Tm, Tw > | op_mul (const algebra::SemiringBase< W > &semiring, const algebra::Series< W, M > &s, const oTw &a, const algebra::polynom< Tm, Tw > &b) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| void | op_in_transpose (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &t) |
| template<typename W, typename M, typename St, typename Tm, typename Tw> | |
| St & | op_rout (const algebra::Series< W, M > &s, St &st, const algebra::polynom< Tm, Tw > &p) |
| template<class W, class M, class Tm, class Tw> | |
| Tm | op_choose_from_supp (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &p) |
| template<typename W, typename M, typename Tm, typename Tw> | |
| algebra::series_traits< algebra::polynom< Tm, Tw > >::support_t | op_support (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &m) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm> | |
| Tw | op_series_get (const algebra::Series< W, M > &s, const algebra::polynom< Tm, Tw > &p, const oTm &m) |
| template<typename W, typename M, typename Tm, typename Tw, typename oTm, typename oTw> | |
| void | op_series_set (const algebra::Series< W, M > &s, algebra::polynom< Tm, Tw > &p, const oTm &m, const oTw &w) |
| template<class W, class M, class Tm, class Tw> | |
| Element< algebra::Series< W, M >, algebra::polynom< Tm, Tw > > | op_choose (const algebra::Series< W, M > &s, SELECTOR2(algebra::polynom< Tm, Tw >)) |
| template<typename Tm, typename Tw, typename W, typename M, typename oTm> | |
| algebra::polynom< Tm, Tw > | op_convert (const algebra::Series< W, M > &s, SELECTOR2(algebra::polynom< Tm, Tw >), SELECTOR(algebra::MonoidBase< M >), const oTm &m_value) |
| template<typename W, typename M> | |
| bool | operator== (const Series< W, M > &, const Series< W, M > &) |
| template<class W, class M, class NewW, class NewM> | |
| mute_series_traits< Series< W, M >, NewW, NewM >::ret | mute_series (const Series< W, M > &s, const NewW &w, const NewM &m) |
| template<typename T, typename U> | |
| std::set< T > | operator^ (std::set< T > set, U other) |
| template<typename T, typename U> | |
| std::set< T > | operator^ (U other, std::set< T > set) |
| template<typename T> | |
| std::set< T > | operator+ (std::set< T > s1, std::set< T > s2) |
Variables | |
| algebra::RationalNumber | identity_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber)) |
| algebra::RationalNumber | zero_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber)) |
| algebra::RationalNumber | identity_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber)) |
| algebra::RationalNumber | zero_value (SELECTOR(algebra::NumericalSemiring), SELECTOR(algebra::RationalNumber)) |
| const rat::exp< Tm, Tw > & | identity_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >)) |
| const rat::exp< Tm, Tw > & | zero_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(rat::exp< Tm, Tw >)) |
|
const algebra::polynom< Tm, Tw > & | identity_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >)) |
|
const algebra::polynom< Tm, Tw > & | zero_value (SELECTOR2(algebra::Series< W, M >), SELECTOR2(algebra::polynom< Tm, Tw >)) |
The algebra namespace in Vaucanson contains all the compounds which are needed to manipulate algebraic structures. Both structural elements (e.g. Alphabets, Monoids, etc.) and implementations of those elements (polynoms, rational expressions, etc.) are presents in this namespace.
| bool op_contains | ( | const algebra::Series< W, M > & | , | |
| const rat::exp< Tm, Tw > & | ||||
| ) |
template<typename S, typename M ...>
... op(Series<S>& series, M& monoid, ...)
and should be instead:
template<typename S, typename M ...>
... op(Series<S>& series, Monoid<M>& monoid, ...)
Definition at line 59 of file krat.hxx.
References pure_service_call.
1.5.1