normalized.hh

Go to the documentation of this file.
00001 // normalized.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 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_NORMALIZED_HH
00018 # define VCSN_ALGORITHMS_NORMALIZED_HH
00019 /* @{ */
00034 // INTERFACE: Automaton normalize(const Automaton& a) { return vcsn::normalize(*a); }
00035 // INTERFACE: GenAutomaton normalize(const GenAutomaton& a) { return vcsn::normalize(*a); }
00036 
00037 // INTERFACE: void normalize_here(Automaton& a) { return vcsn::normalize_here(*a); }
00038 // INTERFACE: void normalize_here(GenAutomaton& a) { return vcsn::normalize_here(*a); }
00039 
00040 // INTERFACE: bool is_normalized(const Automaton& a) { return vcsn::is_normalized(*a); }
00041 // INTERFACE: bool is_normalized(const GenAutomaton& a) { return vcsn::is_normalized(*a); }
00042 
00043 // INTERFACE: void union_of_normalized_here(Automaton& a1, const Automaton& a2) { return vcsn::union_of_normalized_here(*a1, *a2); }
00044 // INTERFACE: void union_of_normalized_here(GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::union_of_normalized_here(*a1, *a2); }
00045 
00046 // INTERFACE: Automaton union_of_normalized(const Automaton& a1, const Automaton& a2) { return vcsn::union_of_normalized(*a1, *a2); }
00047 // INTERFACE: GenAutomaton union_of_normalized(const GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::union_of_normalized(*a1, *a2); }
00048 
00049 // INTERFACE: void concatenate_of_normalized_here(Automaton& a1, const Automaton& a2) { return vcsn::concatenate_of_normalized_here(*a1, *a2); }
00050 // INTERFACE: void concatenate_of_normalized_here(GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::concatenate_of_normalized_here(*a1, *a2); }
00051 
00052 // INTERFACE: Automaton concatenate_of_normalized(const Automaton& a1, const Automaton& a2) { return vcsn::concatenate_of_normalized(*a1, *a2); }
00053 // INTERFACE: GenAutomaton concatenate_of_normalized(const GenAutomaton& a1, const GenAutomaton& a2) { return vcsn::concatenate_of_normalized(*a1, *a2); }
00054 
00055 // INTERFACE: void star_of_normalized_here(Automaton& a) { return vcsn::star_of_normalized_here(*a); }
00056 // INTERFACE: void star_of_normalized_here(GenAutomaton& a) { return vcsn::star_of_normalized_here(*a); }
00057 
00058 // INTERFACE: Automaton star_of_normalized(Automaton& a) { return vcsn::star_of_normalized(*a); }
00059 // INTERFACE: GenAutomaton star_of_normalized(GenAutomaton& a) { return vcsn::star_of_normalized(*a); }
00060 
00061 # include <vaucanson/design_pattern/design_pattern.hh>
00062 
00063 namespace vcsn {
00064 /* @{ */
00066 
00078   template <typename A, typename T>
00079   Element<A, T>
00080   normalize(const Element<A, T>& a);
00081 
00093   template<typename A, typename T>
00094   void
00095   normalize_here(Element<A, T>& a);
00096 
00108   template<typename A, typename T>
00109   bool
00110   is_normalized(const Element<A, T>& a);
00111 
00125   template<typename A, typename T, typename U>
00126   void
00127   union_of_normalized_here(Element<A, T>& lhs,
00128                            const Element<A, U>& rhs);
00129 
00142   template<typename A, typename T, typename U>
00143   Element<A, T>
00144   union_of_normalized(const Element<A, T>& lhs,
00145                       const Element<A, U>& rhs);
00146 
00160   template<typename A, typename T, typename U>
00161   void
00162   concatenate_of_normalized_here(Element<A, T>& lhs,
00163                                  const Element<A, U>& rhs);
00164 
00177   template<typename A, typename T, typename U>
00178   Element<A, T>
00179   concatenate_of_normalized(const Element<A, T>& lhs,
00180                             const Element<A, U>& rhs);
00181 
00194   template<typename A, typename T>
00195   void
00196   star_of_normalized_here(Element<A, T>& a);
00197 
00210   template<typename A, typename T>
00211   Element<A, T>
00212   star_of_normalized(const Element<A, T>& a);
00213 
00216 } // vcsn
00217 
00218 # ifndef VCSN_USE_INTERFACE_ONLY
00219 #  include <vaucanson/algorithms/normalized.hxx>
00220 # endif // VCSN_USE_INTERFACE_ONLY
00221 
00222 #endif // ! VCSN_ALGORITHMS_NORMALIZED_HH

Generated on Sat Jul 29 17:13:09 2006 for Vaucanson by  doxygen 1.4.6