Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 582)
+++ doc/groups.dox	(revision 578)
@@ -436,8 +436,7 @@
 \brief Algorithms for finding matchings in graphs and bipartite graphs.
 
-This group contains the algorithms for calculating
+This group contains algorithm objects and functions to calculate
 matchings in graphs and bipartite graphs. The general matching problem is
-finding a subset of the edges for which each node has at most one incident
-edge.
+finding a subset of the arcs which does not shares common endpoints.
 
 There are several different algorithms for calculate matchings in
Index: lemon/euler.h
===================================================================
--- lemon/euler.h	(revision 578)
+++ lemon/euler.h	(revision 583)
@@ -79,11 +79,17 @@
       : g(gr), nedge(g)
     {
-      if(start==INVALID) start=NodeIt(g);
-      for(NodeIt n(g);n!=INVALID;++n) nedge[n]=OutArcIt(g,n);
-      while(nedge[start]!=INVALID) {
-        euler.push_back(nedge[start]);
-        Node next=g.target(nedge[start]);
-        ++nedge[start];
-        start=next;
+      if (start==INVALID) {
+        NodeIt n(g);
+        while (n!=INVALID && OutArcIt(g,n)==INVALID) ++n;
+        start=n;
+      }
+      if (start!=INVALID) {
+        for (NodeIt n(g); n!=INVALID; ++n) nedge[n]=OutArcIt(g,n);
+        while (nedge[start]!=INVALID) {
+          euler.push_back(nedge[start]);
+          Node next=g.target(nedge[start]);
+          ++nedge[start];
+          start=next;
+        }
       }
     }
@@ -172,13 +178,19 @@
       : g(gr), nedge(g), visited(g, false)
     {
-      if(start==INVALID) start=NodeIt(g);
-      for(NodeIt n(g);n!=INVALID;++n) nedge[n]=OutArcIt(g,n);
-      while(nedge[start]!=INVALID) {
-        euler.push_back(nedge[start]);
-        visited[nedge[start]]=true;
-        Node next=g.target(nedge[start]);
-        ++nedge[start];
-        start=next;
-        while(nedge[start]!=INVALID && visited[nedge[start]]) ++nedge[start];
+      if (start==INVALID) {
+        NodeIt n(g);
+        while (n!=INVALID && OutArcIt(g,n)==INVALID) ++n;
+        start=n;
+      }
+      if (start!=INVALID) {
+        for (NodeIt n(g); n!=INVALID; ++n) nedge[n]=OutArcIt(g,n);
+        while(nedge[start]!=INVALID) {
+          euler.push_back(nedge[start]);
+          visited[nedge[start]]=true;
+          Node next=g.target(nedge[start]);
+          ++nedge[start];
+          start=next;
+          while(nedge[start]!=INVALID && visited[nedge[start]]) ++nedge[start];
+        }
       }
     }
Index: lemon/max_matching.h
===================================================================
--- lemon/max_matching.h	(revision 582)
+++ lemon/max_matching.h	(revision 573)
@@ -38,49 +38,40 @@
   /// \ingroup matching
   ///
-  /// \brief Maximum cardinality matching in general graphs
+  /// \brief Edmonds' alternating forest maximum matching algorithm.
   ///
-  /// This class implements Edmonds' alternating forest matching algorithm
-  /// for finding a maximum cardinality matching in a general graph. 
-  /// It can be started from an arbitrary initial matching 
-  /// (the default is the empty one).
+  /// This class implements Edmonds' alternating forest matching
+  /// algorithm. The algorithm can be started from an arbitrary initial
+  /// matching (the default is the empty one)
   ///
   /// The dual solution of the problem is a map of the nodes to
-  /// \ref MaxMatching::Status "Status", having values \c EVEN (or \c D),
-  /// \c ODD (or \c A) and \c MATCHED (or \c C) defining the Gallai-Edmonds
-  /// decomposition of the graph. The nodes in \c EVEN/D induce a subgraph
-  /// with factor-critical components, the nodes in \c ODD/A form the
-  /// canonical barrier, and the nodes in \c MATCHED/C induce a graph having
-  /// a perfect matching. The number of the factor-critical components
+  /// MaxMatching::Status, having values \c EVEN/D, \c ODD/A and \c
+  /// MATCHED/C showing the Gallai-Edmonds decomposition of the
+  /// graph. The nodes in \c EVEN/D induce a graph with
+  /// factor-critical components, the nodes in \c ODD/A form the
+  /// barrier, and the nodes in \c MATCHED/C induce a graph having a
+  /// perfect matching. The number of the factor-critical components
   /// minus the number of barrier nodes is a lower bound on the
   /// unmatched nodes, and the matching is optimal if and only if this bound is
-  /// tight. This decomposition can be obtained by calling \c
+  /// tight. This decomposition can be attained by calling \c
   /// decomposition() after running the algorithm.
   ///
-  /// \tparam GR The graph type the algorithm runs on.
+  /// \param GR The graph type the algorithm runs on.
   template <typename GR>
   class MaxMatching {
   public:
 
-    /// The graph type of the algorithm
     typedef GR Graph;
     typedef typename Graph::template NodeMap<typename Graph::Arc>
     MatchingMap;
 
-    ///\brief Status constants for Gallai-Edmonds decomposition.
-    ///
-    ///These constants are used for indicating the Gallai-Edmonds 
-    ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
-    ///induce a subgraph with factor-critical components, the nodes with
-    ///status \c ODD (or \c A) form the canonical barrier, and the nodes
-    ///with status \c MATCHED (or \c C) induce a subgraph having a 
-    ///perfect matching.
+    ///\brief Indicates the Gallai-Edmonds decomposition of the graph.
+    ///
+    ///Indicates the Gallai-Edmonds decomposition of the graph. The
+    ///nodes with Status \c EVEN/D induce a graph with factor-critical
+    ///components, the nodes in \c ODD/A form the canonical barrier,
+    ///and the nodes in \c MATCHED/C induce a graph having a perfect
+    ///matching.
     enum Status {
-      EVEN = 1,       ///< = 1. (\c D is an alias for \c EVEN.)
-      D = 1,
-      MATCHED = 0,    ///< = 0. (\c C is an alias for \c MATCHED.)
-      C = 0,
-      ODD = -1,       ///< = -1. (\c A is an alias for \c ODD.)
-      A = -1,
-      UNMATCHED = -2  ///< = -2.
+      EVEN = 1, D = 1, MATCHED = 0, C = 0, ODD = -1, A = -1, UNMATCHED = -2
     };
 
@@ -348,4 +339,6 @@
     }
 
+
+
     void extendOnArc(const Arc& a) {
       Node base = _graph.source(a);
@@ -416,17 +409,20 @@
     }
 
-    /// \name Execution Control
+    /// \name Execution control
     /// The simplest way to execute the algorithm is to use the
-    /// \c run() member function.\n
-    /// If you need better control on the execution, you have to call
-    /// one of the functions \ref init(), \ref greedyInit() or
-    /// \ref matchingInit() first, then you can start the algorithm with
-    /// \ref startSparse() or \ref startDense().
+    /// \c run() member function.
+    /// \n
+
+    /// If you need better control on the execution, you must call
+    /// \ref init(), \ref greedyInit() or \ref matchingInit()
+    /// functions first, then you can start the algorithm with the \ref
+    /// startSparse() or startDense() functions.
 
     ///@{
 
-    /// \brief Set the initial matching to the empty matching.
-    ///
-    /// This function sets the initial matching to the empty matching.
+    /// \brief Sets the actual matching to the empty matching.
+    ///
+    /// Sets the actual matching to the empty matching.
+    ///
     void init() {
       createStructures();
@@ -437,7 +433,7 @@
     }
 
-    /// \brief Find an initial matching in a greedy way.
-    ///
-    /// This function finds an initial matching in a greedy way.
+    ///\brief Finds an initial matching in a greedy way
+    ///
+    ///It finds an initial matching in a greedy way.
     void greedyInit() {
       createStructures();
@@ -463,9 +459,9 @@
 
 
-    /// \brief Initialize the matching from a map.
-    ///
-    /// This function initializes the matching from a \c bool valued edge
-    /// map. This map should have the property that there are no two incident
-    /// edges with \c true value, i.e. it really contains a matching.
+    /// \brief Initialize the matching from a map containing.
+    ///
+    /// Initialize the matching from a \c bool valued \c Edge map. This
+    /// map must have the property that there are no two incident edges
+    /// with true value, ie. it contains a matching.
     /// \return \c true if the map contains a matching.
     template <typename MatchingMap>
@@ -494,10 +490,7 @@
     }
 
-    /// \brief Start Edmonds' algorithm
-    ///
-    /// This function runs the original Edmonds' algorithm.
-    ///
-    /// \pre \ref Init(), \ref greedyInit() or \ref matchingInit() must be
-    /// called before using this function.
+    /// \brief Starts Edmonds' algorithm
+    ///
+    /// If runs the original Edmonds' algorithm.
     void startSparse() {
       for(NodeIt n(_graph); n != INVALID; ++n) {
@@ -511,12 +504,8 @@
     }
 
-    /// \brief Start Edmonds' algorithm with a heuristic improvement 
-    /// for dense graphs
-    ///
-    /// This function runs Edmonds' algorithm with a heuristic of postponing
+    /// \brief Starts Edmonds' algorithm.
+    ///
+    /// It runs Edmonds' algorithm with a heuristic of postponing
     /// shrinks, therefore resulting in a faster algorithm for dense graphs.
-    ///
-    /// \pre \ref Init(), \ref greedyInit() or \ref matchingInit() must be
-    /// called before using this function.
     void startDense() {
       for(NodeIt n(_graph); n != INVALID; ++n) {
@@ -531,9 +520,9 @@
 
 
-    /// \brief Run Edmonds' algorithm
-    ///
-    /// This function runs Edmonds' algorithm. An additional heuristic of 
-    /// postponing shrinks is used for relatively dense graphs 
-    /// (for which <tt>m>=2*n</tt> holds).
+    /// \brief Runs Edmonds' algorithm
+    ///
+    /// Runs Edmonds' algorithm for sparse graphs (<tt>m<2*n</tt>)
+    /// or Edmonds' algorithm with a heuristic of
+    /// postponing shrinks for dense graphs.
     void run() {
       if (countEdges(_graph) < 2 * countNodes(_graph)) {
@@ -548,13 +537,13 @@
     /// @}
 
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum matching.
+    /// \name Primal solution
+    /// Functions to get the primal solution, ie. the matching.
 
     /// @{
 
-    /// \brief Return the size (cardinality) of the matching.
-    ///
-    /// This function returns the size (cardinality) of the current matching. 
-    /// After run() it returns the size of the maximum matching in the graph.
+    ///\brief Returns the size of the current matching.
+    ///
+    ///Returns the size of the current matching. After \ref
+    ///run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
       int size = 0;
@@ -567,25 +556,23 @@
     }
 
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the current 
-    /// matching.
+    /// \brief Returns true when the edge is in the matching.
+    ///
+    /// Returns true when the edge is in the matching.
     bool matching(const Edge& edge) const {
       return edge == (*_matching)[_graph.u(edge)];
     }
 
-    /// \brief Return the matching arc (or edge) incident to the given node.
-    ///
-    /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is 
-    /// not covered by the matching.
+    /// \brief Returns the matching edge incident to the given node.
+    ///
+    /// Returns the matching edge of a \c node in the actual matching or
+    /// INVALID if the \c node is not covered by the actual matching.
     Arc matching(const Node& n) const {
       return (*_matching)[n];
     }
 
-    /// \brief Return the mate of the given node.
-    ///
-    /// This function returns the mate of the given node in the current 
-    /// matching or \c INVALID if the node is not covered by the matching.
+    ///\brief Returns the mate of a node in the actual matching.
+    ///
+    ///Returns the mate of a \c node in the actual matching or
+    ///INVALID if the \c node is not covered by the actual matching.
     Node mate(const Node& n) const {
       return (*_matching)[n] != INVALID ?
@@ -595,22 +582,21 @@
     /// @}
 
-    /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
+    /// \name Dual solution
+    /// Functions to get the dual solution, ie. the decomposition.
+
+    /// @{
+
+    /// \brief Returns the class of the node in the Edmonds-Gallai
     /// decomposition.
-
-    /// @{
-
-    /// \brief Return the status of the given node in the Edmonds-Gallai
+    ///
+    /// Returns the class of the node in the Edmonds-Gallai
     /// decomposition.
-    ///
-    /// This function returns the \ref Status "status" of the given node
-    /// in the Edmonds-Gallai decomposition.
     Status decomposition(const Node& n) const {
       return (*_status)[n];
     }
 
-    /// \brief Return \c true if the given node is in the barrier.
-    ///
-    /// This function returns \c true if the given node is in the barrier.
+    /// \brief Returns true when the node is in the barrier.
+    ///
+    /// Returns true when the node is in the barrier.
     bool barrier(const Node& n) const {
       return (*_status)[n] == ODD;
@@ -630,8 +616,8 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted matching problem is to find a subset of the 
-  /// edges in an undirected graph with maximum overall weight for which 
-  /// each node has at most one incident edge.
-  /// It can be formulated with the following linear program.
+  /// The maximum weighted matching problem is to find undirected
+  /// edges in the graph with maximum overall weight and no two of
+  /// them shares their ends. The problem can be formulated with the
+  /// following linear program.
   /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
   /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2}
@@ -647,5 +633,4 @@
   /// optimality. The solution of the dual problem can be used to check
   /// the result of the algorithm. The dual linear problem is the
-  /// following.
   /** \f[ y_u + y_v + \sum_{B \in \mathcal{O}, uv \in \gamma(B)}
       z_B \ge w_{uv} \quad \forall uv\in E\f] */
@@ -655,40 +640,33 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function. 
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the 
-  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
-  /// which is able to iterate on the nodes of a blossom. 
-  /// If the value type is integer, then the dual solution is multiplied
-  /// by \ref MaxWeightedMatching::dualScale "4".
-  ///
-  /// \tparam GR The graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is 
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
+  /// The algorithm can be executed with \c run() or the \c init() and
+  /// then the \c start() member functions. After it the matching can
+  /// be asked with \c matching() or mate() functions. The dual
+  /// solution can be get with \c nodeValue(), \c blossomNum() and \c
+  /// blossomValue() members and \ref MaxWeightedMatching::BlossomIt
+  /// "BlossomIt" nested class, which is able to iterate on the nodes
+  /// of a blossom. If the value type is integral then the dual
+  /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
   template <typename GR,
             typename WM = typename GR::template EdgeMap<int> >
-#endif
   class MaxWeightedMatching {
   public:
 
-    /// The graph type of the algorithm
+    ///\e
     typedef GR Graph;
-    /// The type of the edge weight map
+    ///\e
     typedef WM WeightMap;
-    /// The value type of the edge weights
+    ///\e
     typedef typename WeightMap::Value Value;
 
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
     /// \brief Scaling factor for dual solution
     ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
+    /// Scaling factor for dual solution, it is equal to 4 or 1
     /// according to the value type.
     static const int dualScale =
       std::numeric_limits<Value>::is_integer ? 4 : 1;
+
+    typedef typename Graph::template NodeMap<typename Graph::Arc>
+    MatchingMap;
 
   private:
@@ -1654,7 +1632,7 @@
     }
 
-    /// \name Execution Control
+    /// \name Execution control
     /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
+    /// \c run() member function.
 
     ///@{
@@ -1662,5 +1640,5 @@
     /// \brief Initialize the algorithm
     ///
-    /// This function initializes the algorithm.
+    /// Initialize the algorithm
     void init() {
       createStructures();
@@ -1714,9 +1692,7 @@
     }
 
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
+    /// \brief Starts the algorithm
+    ///
+    /// Starts the algorithm
     void start() {
       enum OpType {
@@ -1801,7 +1777,7 @@
     }
 
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedMatching algorithm.
+    /// \brief Runs %MaxWeightedMatching algorithm.
+    ///
+    /// This method runs the %MaxWeightedMatching algorithm.
     ///
     /// \note mwm.run() is just a shortcut of the following code.
@@ -1817,17 +1793,12 @@
     /// @}
 
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted 
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
+    /// \name Primal solution
+    /// Functions to get the primal solution, ie. the matching.
 
     /// @{
 
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the weight of the matching.
+    ///
+    /// Returns the weight of the matching.
     Value matchingValue() const {
       Value sum = 0;
@@ -1840,9 +1811,7 @@
     }
 
-    /// \brief Return the size (cardinality) of the matching.
-    ///
-    /// This function returns the size (cardinality) of the found matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the cardinality of the matching.
+    ///
+    /// Returns the cardinality of the matching.
     int matchingSize() const {
       int num = 0;
@@ -1855,31 +1824,23 @@
     }
 
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the found 
-    /// matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns true when the edge is in the matching.
+    ///
+    /// Returns true when the edge is in the matching.
     bool matching(const Edge& edge) const {
       return edge == (*_matching)[_graph.u(edge)];
     }
 
-    /// \brief Return the matching arc (or edge) incident to the given node.
-    ///
-    /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is 
-    /// not covered by the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the incident matching arc.
+    ///
+    /// Returns the incident matching arc from given node. If the
+    /// node is not matched then it gives back \c INVALID.
     Arc matching(const Node& node) const {
       return (*_matching)[node];
     }
 
-    /// \brief Return the mate of the given node.
-    ///
-    /// This function returns the mate of the given node in the found 
-    /// matching or \c INVALID if the node is not covered by the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the mate of the node.
+    ///
+    /// Returns the adjancent node in a mathcing arc. If the node is
+    /// not matched then it gives back \c INVALID.
     Node mate(const Node& node) const {
       return (*_matching)[node] != INVALID ?
@@ -1889,18 +1850,13 @@
     /// @}
 
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
+    /// \name Dual solution
+    /// Functions to get the dual solution.
 
     /// @{
 
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution. 
-    /// It should be equal to the primal value scaled by \ref dualScale 
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the value of the dual solution.
+    ///
+    /// Returns the value of the dual solution. It should be equal to
+    /// the primal value scaled by \ref dualScale "dual scale".
     Value dualValue() const {
       Value sum = 0;
@@ -1914,18 +1870,14 @@
     }
 
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the value of the node.
+    ///
+    /// Returns the the value of the node.
     Value nodeValue(const Node& n) const {
       return (*_node_potential)[n];
     }
 
-    /// \brief Return the number of the blossoms in the basis.
-    ///
-    /// This function returns the number of the blossoms in the basis.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the number of the blossoms in the basis.
+    ///
+    /// Returns the number of the blossoms in the basis.
     /// \see BlossomIt
     int blossomNum() const {
@@ -1933,29 +1885,25 @@
     }
 
-    /// \brief Return the number of the nodes in the given blossom.
-    ///
-    /// This function returns the number of the nodes in the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    /// \see BlossomIt
+
+    /// \brief Returns the number of the nodes in the blossom.
+    ///
+    /// Returns the number of the nodes in the blossom.
     int blossomSize(int k) const {
       return _blossom_potential[k].end - _blossom_potential[k].begin;
     }
 
-    /// \brief Return the dual value (ptential) of the given blossom.
-    ///
-    /// This function returns the dual value (ptential) of the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the value of the blossom.
+    ///
+    /// Returns the the value of the blossom.
+    /// \see BlossomIt
     Value blossomValue(int k) const {
       return _blossom_potential[k].value;
     }
 
-    /// \brief Iterator for obtaining the nodes of a blossom.
-    ///
-    /// This class provides an iterator for obtaining the nodes of the 
-    /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a 
-    /// MaxWeightedMatching class and execute it.
+    /// \brief Iterator for obtaining the nodes of the blossom.
+    ///
+    /// Iterator for obtaining the nodes of the blossom. This class
+    /// provides a common lemon style iterator for listing a
+    /// subset of the nodes.
     class BlossomIt {
     public:
@@ -1963,9 +1911,5 @@
       /// \brief Constructor.
       ///
-      /// Constructor to get the nodes of the given variable.
-      ///
-      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
-      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
-      /// called before initializing this iterator.
+      /// Constructor to get the nodes of the variable.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
         : _algorithm(&algorithm)
@@ -1975,7 +1919,7 @@
       }
 
-      /// \brief Conversion to \c Node.
+      /// \brief Conversion to node.
       ///
-      /// Conversion to \c Node.
+      /// Conversion to node.
       operator Node() const {
         return _algorithm->_blossom_node_list[_index];
@@ -2019,8 +1963,8 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted perfect matching problem is to find a subset of 
-  /// the edges in an undirected graph with maximum overall weight for which 
-  /// each node has exactly one incident edge.
-  /// It can be formulated with the following linear program.
+  /// The maximum weighted matching problem is to find undirected
+  /// edges in the graph with maximum overall weight and no two of
+  /// them shares their ends and covers all nodes. The problem can be
+  /// formulated with the following linear program.
   /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f]
   /** \f[ \sum_{e \in \gamma(B)}x_e \le \frac{\vert B \vert - 1}{2}
@@ -2036,5 +1980,4 @@
   /// optimality. The solution of the dual problem can be used to check
   /// the result of the algorithm. The dual linear problem is the
-  /// following.
   /** \f[ y_u + y_v + \sum_{B \in \mathcal{O}, uv \in \gamma(B)}z_B \ge
       w_{uv} \quad \forall uv\in E\f] */
@@ -2043,29 +1986,19 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function. 
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the 
-  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
-  /// which is able to iterate on the nodes of a blossom. 
-  /// If the value type is integer, then the dual solution is multiplied
-  /// by \ref MaxWeightedMatching::dualScale "4".
-  ///
-  /// \tparam GR The graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is 
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
+  /// The algorithm can be executed with \c run() or the \c init() and
+  /// then the \c start() member functions. After it the matching can
+  /// be asked with \c matching() or mate() functions. The dual
+  /// solution can be get with \c nodeValue(), \c blossomNum() and \c
+  /// blossomValue() members and \ref MaxWeightedMatching::BlossomIt
+  /// "BlossomIt" nested class which is able to iterate on the nodes
+  /// of a blossom. If the value type is integral then the dual
+  /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
   template <typename GR,
             typename WM = typename GR::template EdgeMap<int> >
-#endif
   class MaxWeightedPerfectMatching {
   public:
 
-    /// The graph type of the algorithm
     typedef GR Graph;
-    /// The type of the edge weight map
     typedef WM WeightMap;
-    /// The value type of the edge weights
     typedef typename WeightMap::Value Value;
 
@@ -2886,7 +2819,7 @@
     }
 
-    /// \name Execution Control
+    /// \name Execution control
     /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
+    /// \c run() member function.
 
     ///@{
@@ -2894,5 +2827,5 @@
     /// \brief Initialize the algorithm
     ///
-    /// This function initializes the algorithm.
+    /// Initialize the algorithm
     void init() {
       createStructures();
@@ -2942,9 +2875,7 @@
     }
 
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
+    /// \brief Starts the algorithm
+    ///
+    /// Starts the algorithm
     bool start() {
       enum OpType {
@@ -3010,12 +2941,12 @@
     }
 
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedPerfectMatching algorithm.
-    ///
-    /// \note mwpm.run() is just a shortcut of the following code.
+    /// \brief Runs %MaxWeightedPerfectMatching algorithm.
+    ///
+    /// This method runs the %MaxWeightedPerfectMatching algorithm.
+    ///
+    /// \note mwm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwpm.init();
-    ///   mwpm.start();
+    ///   mwm.init();
+    ///   mwm.start();
     /// \endcode
     bool run() {
@@ -3026,17 +2957,12 @@
     /// @}
 
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted 
-    /// perfect matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
+    /// \name Primal solution
+    /// Functions to get the primal solution, ie. the matching.
 
     /// @{
 
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the matching value.
+    ///
+    /// Returns the matching value.
     Value matchingValue() const {
       Value sum = 0;
@@ -3049,31 +2975,21 @@
     }
 
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the found 
-    /// matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns true when the edge is in the matching.
+    ///
+    /// Returns true when the edge is in the matching.
     bool matching(const Edge& edge) const {
       return static_cast<const Edge&>((*_matching)[_graph.u(edge)]) == edge;
     }
 
-    /// \brief Return the matching arc (or edge) incident to the given node.
-    ///
-    /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is 
-    /// not covered by the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the incident matching edge.
+    ///
+    /// Returns the incident matching arc from given edge.
     Arc matching(const Node& node) const {
       return (*_matching)[node];
     }
 
-    /// \brief Return the mate of the given node.
-    ///
-    /// This function returns the mate of the given node in the found 
-    /// matching or \c INVALID if the node is not covered by the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the mate of the node.
+    ///
+    /// Returns the adjancent node in a mathcing arc.
     Node mate(const Node& node) const {
       return _graph.target((*_matching)[node]);
@@ -3082,18 +2998,13 @@
     /// @}
 
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
+    /// \name Dual solution
+    /// Functions to get the dual solution.
 
     /// @{
 
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution. 
-    /// It should be equal to the primal value scaled by \ref dualScale 
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the value of the dual solution.
+    ///
+    /// Returns the value of the dual solution. It should be equal to
+    /// the primal value scaled by \ref dualScale "dual scale".
     Value dualValue() const {
       Value sum = 0;
@@ -3107,18 +3018,14 @@
     }
 
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the value of the node.
+    ///
+    /// Returns the the value of the node.
     Value nodeValue(const Node& n) const {
       return (*_node_potential)[n];
     }
 
-    /// \brief Return the number of the blossoms in the basis.
-    ///
-    /// This function returns the number of the blossoms in the basis.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the number of the blossoms in the basis.
+    ///
+    /// Returns the number of the blossoms in the basis.
     /// \see BlossomIt
     int blossomNum() const {
@@ -3126,29 +3033,25 @@
     }
 
-    /// \brief Return the number of the nodes in the given blossom.
-    ///
-    /// This function returns the number of the nodes in the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    /// \see BlossomIt
+
+    /// \brief Returns the number of the nodes in the blossom.
+    ///
+    /// Returns the number of the nodes in the blossom.
     int blossomSize(int k) const {
       return _blossom_potential[k].end - _blossom_potential[k].begin;
     }
 
-    /// \brief Return the dual value (ptential) of the given blossom.
-    ///
-    /// This function returns the dual value (ptential) of the given blossom.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
+    /// \brief Returns the value of the blossom.
+    ///
+    /// Returns the the value of the blossom.
+    /// \see BlossomIt
     Value blossomValue(int k) const {
       return _blossom_potential[k].value;
     }
 
-    /// \brief Iterator for obtaining the nodes of a blossom.
-    ///
-    /// This class provides an iterator for obtaining the nodes of the 
-    /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a 
-    /// MaxWeightedPerfectMatching class and execute it.
+    /// \brief Iterator for obtaining the nodes of the blossom.
+    ///
+    /// Iterator for obtaining the nodes of the blossom. This class
+    /// provides a common lemon style iterator for listing a
+    /// subset of the nodes.
     class BlossomIt {
     public:
@@ -3156,9 +3059,5 @@
       /// \brief Constructor.
       ///
-      /// Constructor to get the nodes of the given variable.
-      ///
-      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
-      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
-      /// must be called before initializing this iterator.
+      /// Constructor to get the nodes of the variable.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
         : _algorithm(&algorithm)
@@ -3168,7 +3067,7 @@
       }
 
-      /// \brief Conversion to \c Node.
+      /// \brief Conversion to node.
       ///
-      /// Conversion to \c Node.
+      /// Conversion to node.
       operator Node() const {
         return _algorithm->_blossom_node_list[_index];
@@ -3185,10 +3084,10 @@
       /// \brief Validity checking
       ///
-      /// This function checks whether the iterator is invalid.
+      /// Checks whether the iterator is invalid.
       bool operator==(Invalid) const { return _index == _last; }
 
       /// \brief Validity checking
       ///
-      /// This function checks whether the iterator is valid.
+      /// Checks whether the iterator is valid.
       bool operator!=(Invalid) const { return _index != _last; }
 
@@ -3203,4 +3102,5 @@
   };
 
+
 } //END OF NAMESPACE LEMON
 
Index: test/max_matching_test.cc
===================================================================
--- test/max_matching_test.cc	(revision 582)
+++ test/max_matching_test.cc	(revision 440)
@@ -21,12 +21,10 @@
 #include <vector>
 #include <queue>
+#include <lemon/math.h>
 #include <cstdlib>
 
 #include <lemon/max_matching.h>
 #include <lemon/smart_graph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
 #include <lemon/lgf_reader.h>
-#include <lemon/math.h>
 
 #include "test_tools.h"
@@ -113,106 +111,4 @@
 };
 
-void checkMaxMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<bool> MatMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  MatMap mat(g);
-
-  MaxMatching<Graph> mat_test(g);
-  const MaxMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.greedyInit();
-  mat_test.matchingInit(mat);
-  mat_test.startSparse();
-  mat_test.startDense();
-  mat_test.run();
-  
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const_mat_test.mate(n);
-
-  MaxMatching<Graph>::Status stat = 
-    const_mat_test.decomposition(n);
-  const_mat_test.barrier(n);
-  
-  ignore_unused_variable_warning(stat);
-}
-
-void checkMaxWeightedMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedMatching<Graph> mat_test(g, w);
-  const MaxWeightedMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-  
-  const_mat_test.matchingValue();
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const_mat_test.mate(n);
-  
-  int k = 0;
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-  const_mat_test.blossomNum();
-  const_mat_test.blossomSize(k);
-  const_mat_test.blossomValue(k);
-}
-
-void checkMaxWeightedPerfectMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedPerfectMatching<Graph> mat_test(g, w);
-  const MaxWeightedPerfectMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-  
-  const_mat_test.matchingValue();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const_mat_test.mate(n);
-  
-  int k = 0;
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-  const_mat_test.blossomNum();
-  const_mat_test.blossomSize(k);
-  const_mat_test.blossomValue(k);
-}
-
 void checkMatching(const SmartGraph& graph,
                    const MaxMatching<SmartGraph>& mm) {
