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 | MonoidBase |
The base class of all structures that are monoids. More... | |
| struct | identity_as |
| struct | zero_as |
| 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 > |
| class | static_ranged |
| struct | static_char_interval |
| struct | letter_traits< static_ranged< T, Interval > > |
| class | RationalNumber |
| Rational numbers class. More... | |
| class | CoefficientEval |
| class | ExpConvertVisitor |
| class | KRatExpToken |
| Schrödinger's token for rational expression lexing. More... | |
| struct | Lexer |
| Lexer class for the rational expression parser. More... | |
| struct | Parser |
| Parser class used in the parse() function. More... | |
| 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 |
| 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 > > |
Namespaces | |
| namespace | small_alpha_letter |
| namespace | char_letter |
| namespace | char_pair |
| namespace | weighted_letter |
| namespace | int_letter |
| namespace | krat_exp_lexing |
| Misc. declarations used for rational expression lexing. | |
Functions | |
| template<class F, class S> | |
| bool | operator== (const FreeMonoidProduct< F, S > &m1, const FreeMonoidProduct< F, S > &m2) |
| template<typename A> | |
| bool | operator== (const FreeMonoid< A > &a, const FreeMonoid< A > &b) |
| 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<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 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, 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> | |
| 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<class Series, class T> | |
| Element< Series, T > | expand (const Element< Series, T > &exp) |
| template<class S, class E> | |
| E | do_expand (const algebra::SeriesBase< S > &, const E &exp) |
| 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) |
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.
1.4.6