- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

# standard.hh

Go to the documentation of this file.

    00001 // standard.hh: this file is part of the Vaucanson project.
    00002 //
    00003 // Vaucanson, a generic library for finite state machines.
    00004 //
    00005 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2011 The Vaucanson Group.
    00006 //
    00007 // This program is free software; you can redistribute it and/or
    00008 // modify it under the terms of the GNU General Public License
    00009 // as published by the Free Software Foundation; either version 2
    00010 // of the License, or (at your option) any later version.
    00011 //
    00012 // The complete GNU General Public Licence Notice can be found as the
    00013 // `COPYING' file in the root directory.
    00014 //
    00015 // The Vaucanson Group consists of people listed in the `AUTHORS' file.
    00016 //
    00017 #ifndef VCSN_ALGORITHMS_STANDARD_HH
    00018 # define VCSN_ALGORITHMS_STANDARD_HH
    00019
    00040 // INTERFACE: void union_here(Automaton& a1, const Automaton& a2) { return vcsn::union_here(*a1, *a2); }
    00041 // INTERFACE: void union_here(GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::union_here(*a1, *a2); }
    00042
    00043 // INTERFACE: Automaton union_(const Automaton& a1, const Automaton& a2) { return vcsn::union_(*a1, *a2); }
    00044 // INTERFACE: GenAutomaton union_(const GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::union_(*a1, *a2); }
    00045
    00046 // INTERFACE: bool is_standard(const Automaton& a) { return vcsn::is_standard(*a); }
    00047 // INTERFACE: bool is_standard(const GenAutomaton& a) { return vcsn::is_standard(*a); }
    00048
    00049 // INTERFACE: void standardize(Automaton& a) { return vcsn::standardize(*a); }
    00050 // INTERFACE: void standardize(GenAutomaton& a) { return vcsn::standardize(*a); }
    00051
    00052 // INTERFACE: void sum_of_standard_here(Automaton& a1, const Automaton& a2) { return vcsn::sum_of_standard_here(*a1, *a2); }
    00053 // INTERFACE: void sum_of_standard_here(GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::sum_of_standard_here(*a1, *a2); }
    00054
    00055 // INTERFACE: Automaton sum_of_standard(const Automaton& a1, const Automaton& a2) { return vcsn::sum_of_standard(*a1, *a2); }
    00056 // INTERFACE: GenAutomaton sum_of_standard(const GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::sum_of_standard(*a1, *a2); }
    00057
    00058 // INTERFACE: void concat_of_standard_here(Automaton& a1, const Automaton& a2) { return vcsn::concat_of_standard_here(*a1, *a2); }
    00059 // INTERFACE: void concat_of_standard_here(GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::concat_of_standard_here(*a1, *a2); }
    00060
    00061 // INTERFACE: Automaton concat_of_standard(const Automaton& a1, const Automaton& a2) { return vcsn::concat_of_standard(*a1, *a2); }
    00062 // INTERFACE: GenAutomaton concat_of_standard(const GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::concat_of_standard(*a1, *a2); }
    00063
    00064 // INTERFACE: void star_of_standard_here(Automaton& a) { return vcsn::star_of_standard_here(*a); }
    00065 // INTERFACE: void star_of_standard_here(GenAutomaton& a) { return vcsn::star_of_standard_here(*a); }
    00066
    00067 // INTERFACE: Automaton star_of_standard(const Automaton& a) { return vcsn::star_of_standard(*a); }
    00068 // INTERFACE: GenAutomaton star_of_standard(const GenAutomaton& a) { return vcsn::star_of_standard(*a); }
    00069
    00070 // INTERFACE: void left_mult_of_standard_here(Automaton& a, const Automaton::series_set_elt_t& k) { return vcsn::left_mult_of_standard_here(a, k);
    00071 // INTERFACE: void left_mult_of_standard_here(GenAutomaton& a, const GenAutomaton::series_set_elt_t& k) { return vcsn::left_mult_of_standard_here(a, k);
    00072 // INTERFACE: void right_mult_of_standard_here(Automaton& a, const Automaton::series_set_elt_t& k) { return vcsn::right_mult_of_standard_here(a, k);
    00073 // INTERFACE: void right_mult_of_standard_here(GenAutomaton& a, const GenAutomaton::series_set_elt_t& k) { return vcsn::right_mult_of_standard_here(a, k);
    00074
    00075 # include <vaucanson/design_pattern/design_pattern.hh>
    00076
    00077 namespace vcsn {
    00078
    00092   template<typename A, typename AI1, typename AI2>
    00093   void
    00094   union_here(Element<A, AI1>& lhs, const Element<A, AI2>& rhs);
    00095
    00111   template<typename A, typename AI1, typename AI2>
    00112   Element<A, AI1>
    00113   union_(const Element<A, AI1>& lhs, const Element<A, AI2>& rhs);
    00114
    00115
    00123   template<typename A, typename AI>
    00124   bool
    00125   is_standard(const Element<A, AI>& a);
    00126
    00134   template<typename A, typename AI>
    00135   void
    00136   standardize(Element<A, AI>& a);
    00137
    00149   template<typename A, typename AI1, typename AI2>
    00150   void
    00151   sum_of_standard_here(Element<A, AI1>& lhs,
    00152                        const Element<A, AI2>& rhs);
    00153
    00165   template<typename A, typename AI1, typename AI2>
    00166   Element<A, AI1>
    00167   sum_of_standard(const Element<A, AI1>& lhs,
    00168                   const Element<A, AI2>& rhs);
    00169
    00181   template<typename A, typename AI1, typename AI2>
    00182   void
    00183   concat_of_standard_here(Element<A, AI1>& lhs,
    00184                           const Element<A, AI2>& rhs);
    00185
    00197   template<typename A, typename AI1, typename AI2>
    00198   Element<A, AI1>
    00199   concat_of_standard(const Element<A, AI1>& lhs,
    00200                      const Element<A, AI2>& rhs);
    00211   template<typename A, typename AI>
    00212   void
    00213   star_of_standard_here(Element<A, AI>& a);
    00214
    00225   template<typename A, typename AI>
    00226   Element<A, AI>
    00227   star_of_standard(const Element<A, AI>& a);
    00228
    00234   template <typename A, typename AI>
    00235   void
    00236   left_mult_of_standard_here(Element<A, AI>& aut,
    00237                              const typename Element<A, AI>::series_set_elt_t& k);
    00238
    00244   template <typename A, typename AI>
    00245   void
    00246   right_mult_of_standard_here(Element<A, AI>& aut,
    00247                               const typename Element<A, AI>::series_set_elt_t& k);
    00248
    00251 } // vcsn
    00252
    00253 # if !defined VCSN_USE_INTERFACE_ONLY && !defined VCSN_USE_LIB
    00254 #  include <vaucanson/algorithms/standard.hxx>
    00255 # endif // VCSN_USE_INTERFACE_ONLY
    00256
    00257 #endif // ! VCSN_ALGORITHMS_STANDARD_HH