Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 606)
+++ lemon/bin_heap.h	(revision 631)
@@ -74,7 +74,7 @@
     /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
     enum State {
-      IN_HEAP = 0,    ///< \e
-      PRE_HEAP = -1,  ///< \e
-      POST_HEAP = -2  ///< \e
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
     };
 
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 627)
+++ lemon/concepts/graph_components.h	(revision 631)
@@ -603,5 +603,5 @@
       typedef IterableDigraphComponent Digraph;
 
-      /// \name Base iteration
+      /// \name Base Iteration
       ///
       /// This interface provides functions for iteration on digraph items.
@@ -655,5 +655,5 @@
       /// @}
 
-      /// \name Class based iteration
+      /// \name Class Based Iteration
       ///
       /// This interface provides iterator classes for digraph items.
@@ -780,5 +780,5 @@
       typedef IterableGraphComponent Graph;
 
-      /// \name Base iteration
+      /// \name Base Iteration
       ///
       /// This interface provides functions for iteration on edges.
@@ -819,5 +819,5 @@
       /// @}
 
-      /// \name Class based iteration
+      /// \name Class Based Iteration
       ///
       /// This interface provides iterator classes for edges.
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 606)
+++ lemon/concepts/heap.h	(revision 631)
@@ -72,7 +72,7 @@
       /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
       enum State {
-        IN_HEAP = 0,    ///< The "in heap" state constant.
-        PRE_HEAP = -1,  ///< The "pre heap" state constant.
-        POST_HEAP = -2  ///< The "post heap" state constant.
+        IN_HEAP = 0,    ///< = 0. The "in heap" state constant.
+        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.
+        POST_HEAP = -2  ///< = -2. The "post heap" state constant.
       };
 
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 525)
+++ lemon/dfs.h	(revision 631)
@@ -207,5 +207,5 @@
     typedef Dfs Create;
 
-    ///\name Named template parameters
+    ///\name Named Template Parameters
 
     ///@{
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 606)
+++ lemon/dijkstra.h	(revision 631)
@@ -287,5 +287,5 @@
     typedef Dijkstra Create;
 
-    ///\name Named template parameters
+    ///\name Named Template Parameters
 
     ///@{
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 608)
+++ lemon/dimacs.h	(revision 631)
@@ -38,9 +38,14 @@
   struct DimacsDescriptor
   {
-    ///File type enum
-    enum Type
-      {
-        NONE, MIN, MAX, SP, MAT
-      };
+    ///\brief DIMACS file type enum
+    ///
+    ///DIMACS file type enum.
+    enum Type {
+      NONE,  ///< Undefined type.
+      MIN,   ///< DIMACS file type for minimum cost flow problems.
+      MAX,   ///< DIMACS file type for maximum flow problems.
+      SP,    ///< DIMACS file type for shostest path problems.
+      MAT    ///< DIMACS file type for plain graphs and matching problems.
+    };
     ///The file type
     Type type;
@@ -50,5 +55,5 @@
     int edgeNum;
     int lineShift;
-    /// Constructor. Sets the type to NONE.
+    ///Constructor. It sets the type to \c NONE.
     DimacsDescriptor() : type(NONE) {}
   };
@@ -56,8 +61,8 @@
   ///Discover the type of a DIMACS file
 
-  ///It starts seeking the beginning of the file for the problem type
-  ///and size info. The found data is returned in a special struct
-  ///that can be evaluated and passed to the appropriate reader
-  ///function.
+  ///This function starts seeking the beginning of the given file for the
+  ///problem type and size info. 
+  ///The found data is returned in a special struct that can be evaluated
+  ///and passed to the appropriate reader function.
   DimacsDescriptor dimacsType(std::istream& is)
   {
@@ -97,6 +102,5 @@
 
 
-
-  /// DIMACS minimum cost flow reader function.
+  /// \brief DIMACS minimum cost flow reader function.
   ///
   /// This function reads a minimum cost flow instance from DIMACS format,
@@ -254,5 +258,5 @@
   }
 
-  /// DIMACS maximum flow reader function.
+  /// \brief DIMACS maximum flow reader function.
   ///
   /// This function reads a maximum flow instance from DIMACS format,
@@ -288,5 +292,5 @@
   }
 
-  /// DIMACS shortest path reader function.
+  /// \brief DIMACS shortest path reader function.
   ///
   /// This function reads a shortest path instance from DIMACS format,
@@ -314,5 +318,5 @@
   }
 
-  /// DIMACS capacitated digraph reader function.
+  /// \brief DIMACS capacitated digraph reader function.
   ///
   /// This function reads an arc capacitated digraph instance from
@@ -360,9 +364,9 @@
   }
   
-  /// DIMACS plain (di)graph reader function.
-  ///
-  /// This function reads a (di)graph without any designated nodes and
-  /// maps from DIMACS format, i.e. from DIMACS files having a line
-  /// starting with
+  /// \brief DIMACS plain (di)graph reader function.
+  ///
+  /// This function reads a plain (di)graph without any designated nodes
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
+  /// DIMACS files having a line starting with
   /// \code
   ///   p mat
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 606)
+++ lemon/graph_to_eps.h	(revision 631)
@@ -269,20 +269,16 @@
     ///\image html nodeshape_1.png
     ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
-    ///
     SQUARE=1,
     /// = 2
     ///\image html nodeshape_2.png
     ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
-    ///
     DIAMOND=2,
     /// = 3
     ///\image html nodeshape_3.png
-    ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm
-    ///
+    ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm
     MALE=3,
     /// = 4
     ///\image html nodeshape_4.png
-    ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm
-    ///
+    ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm
     FEMALE=4
   };
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 463)
+++ lemon/kruskal.h	(revision 631)
@@ -249,9 +249,9 @@
   /// \ingroup spantree
   ///
-  /// \brief Kruskal algorithm to find a minimum cost spanning tree of
+  /// \brief Kruskal's algorithm for finding a minimum cost spanning tree of
   /// a graph.
   ///
   /// This function runs Kruskal's algorithm to find a minimum cost
-  /// spanning tree.
+  /// spanning tree of a graph.
   /// Due to some C++ hacking, it accepts various input and output types.
   ///
@@ -265,7 +265,7 @@
   /// It can be one of the following choices.
   /// - An STL compatible 'Forward Container' with
-  /// <tt>std::pair<GR::Arc,X></tt> or
-  /// <tt>std::pair<GR::Edge,X></tt> as its <tt>value_type</tt>, where
-  /// \c X is the type of the costs. The pairs indicates the arcs/edges
+  /// <tt>std::pair<GR::Arc,C></tt> or
+  /// <tt>std::pair<GR::Edge,C></tt> as its <tt>value_type</tt>, where
+  /// \c C is the type of the costs. The pairs indicates the arcs/edges
   /// along with the assigned cost. <em>They must be in a
   /// cost-ascending order.</em>
@@ -274,6 +274,6 @@
   ///
   /// \retval out Here we also have a choice.
-  /// - It can be a writable \c bool arc/edge map. After running the
-  /// algorithm it will contain the found minimum cost spanning
+  /// - It can be a writable arc/edge map with \c bool value type. After
+  /// running the algorithm it will contain the found minimum cost spanning
   /// tree: the value of an arc/edge will be set to \c true if it belongs
   /// to the tree, otherwise it will be set to \c false. The value of
@@ -302,6 +302,6 @@
 
 #ifdef DOXYGEN
-  template <class Graph, class In, class Out>
-  Value kruskal(GR const& g, const In& in, Out& out)
+  template <typename Graph, typename In, typename Out>
+  Value kruskal(const Graph& g, const In& in, Out& out)
 #else
   template <class Graph, class In, class Out>
@@ -315,6 +315,4 @@
 
 
-
-
   template <class Graph, class In, class Out>
   inline typename _kruskal_bits::KruskalValueSelector<In>::Value
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 606)
+++ lemon/lgf_reader.h	(revision 631)
@@ -594,5 +594,5 @@
   public:
 
-    /// \name Reading rules
+    /// \name Reading Rules
     /// @{
 
@@ -699,5 +699,5 @@
     /// @}
 
-    /// \name Select section by name
+    /// \name Select Section by Name
     /// @{
 
@@ -728,5 +728,5 @@
     /// @}
 
-    /// \name Using previously constructed node or arc set
+    /// \name Using Previously Constructed Node or Arc Set
     /// @{
 
@@ -1117,5 +1117,5 @@
   public:
 
-    /// \name Execution of the reader
+    /// \name Execution of the Reader
     /// @{
 
@@ -1390,5 +1390,5 @@
   public:
 
-    /// \name Reading rules
+    /// \name Reading Rules
     /// @{
 
@@ -1541,5 +1541,5 @@
     /// @}
 
-    /// \name Select section by name
+    /// \name Select Section by Name
     /// @{
 
@@ -1570,5 +1570,5 @@
     /// @}
 
-    /// \name Using previously constructed node or edge set
+    /// \name Using Previously Constructed Node or Edge Set
     /// @{
 
@@ -1960,5 +1960,5 @@
   public:
 
-    /// \name Execution of the reader
+    /// \name Execution of the Reader
     /// @{
 
@@ -2159,5 +2159,5 @@
   public:
 
-    /// \name Section readers
+    /// \name Section Readers
     /// @{
 
@@ -2258,5 +2258,5 @@
 
 
-    /// \name Execution of the reader
+    /// \name Execution of the Reader
     /// @{
 
@@ -2440,5 +2440,5 @@
 
 
-    /// \name Node sections
+    /// \name Node Sections
     /// @{
 
@@ -2466,5 +2466,5 @@
     /// @}
 
-    /// \name Arc/Edge sections
+    /// \name Arc/Edge Sections
     /// @{
 
@@ -2524,5 +2524,5 @@
     /// @}
 
-    /// \name Attribute sections
+    /// \name Attribute Sections
     /// @{
 
@@ -2550,5 +2550,5 @@
     /// @}
 
-    /// \name Extra sections
+    /// \name Extra Sections
     /// @{
 
@@ -2626,5 +2626,5 @@
   public:
 
-    /// \name Execution of the contents reader
+    /// \name Execution of the Contents Reader
     /// @{
 
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 606)
+++ lemon/lgf_writer.h	(revision 631)
@@ -539,5 +539,5 @@
   public:
 
-    /// \name Writing rules
+    /// \name Writing Rules
     /// @{
 
@@ -642,5 +642,5 @@
     }
 
-    /// \name Section captions
+    /// \name Section Captions
     /// @{
 
@@ -669,5 +669,5 @@
     }
 
-    /// \name Skipping section
+    /// \name Skipping Section
     /// @{
 
@@ -886,5 +886,5 @@
   public:
 
-    /// \name Execution of the writer
+    /// \name Execution of the Writer
     /// @{
 
@@ -1107,5 +1107,5 @@
   public:
 
-    /// \name Writing rules
+    /// \name Writing Rules
     /// @{
 
@@ -1256,5 +1256,5 @@
     }
 
-    /// \name Section captions
+    /// \name Section Captions
     /// @{
 
@@ -1283,5 +1283,5 @@
     }
 
-    /// \name Skipping section
+    /// \name Skipping Section
     /// @{
 
@@ -1500,5 +1500,5 @@
   public:
 
-    /// \name Execution of the writer
+    /// \name Execution of the Writer
     /// @{
 
@@ -1652,5 +1652,5 @@
   public:
 
-    /// \name Section writers
+    /// \name Section Writers
     /// @{
 
@@ -1719,5 +1719,5 @@
 
 
-    /// \name Execution of the writer
+    /// \name Execution of the Writer
     /// @{
 
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 623)
+++ lemon/lp_base.h	(revision 631)
@@ -53,10 +53,10 @@
     ///Possible outcomes of an LP solving procedure
     enum SolveExitStatus {
-      ///This means that the problem has been successfully solved: either
+      /// = 0. It means that the problem has been successfully solved: either
       ///an optimal solution has been found or infeasibility/unboundedness
       ///has been proved.
       SOLVED = 0,
-      ///Any other case (including the case when some user specified
-      ///limit has been exceeded)
+      /// = 1. Any other case (including the case when some user specified
+      ///limit has been exceeded).
       UNSOLVED = 1
     };
@@ -72,13 +72,13 @@
     ///Enum for \c messageLevel() parameter
     enum MessageLevel {
-      /// no output (default value)
+      /// No output (default value).
       MESSAGE_NOTHING,
-      /// error messages only
+      /// Error messages only.
       MESSAGE_ERROR,
-      /// warnings
+      /// Warnings.
       MESSAGE_WARNING,
-      /// normal output
+      /// Normal output.
       MESSAGE_NORMAL,
-      /// verbose output
+      /// Verbose output.
       MESSAGE_VERBOSE
     };
@@ -1006,5 +1006,5 @@
     const char* solverName() const {return _solverName();}
 
-    ///\name Build up and modify the LP
+    ///\name Build Up and Modify the LP
 
     ///@{
@@ -1789,13 +1789,13 @@
     /// The problem types for primal and dual problems
     enum ProblemType {
-      ///Feasible solution hasn't been found (but may exist).
+      /// = 0. Feasible solution hasn't been found (but may exist).
       UNDEFINED = 0,
-      ///The problem has no feasible solution
+      /// = 1. The problem has no feasible solution.
       INFEASIBLE = 1,
-      ///Feasible solution found
+      /// = 2. Feasible solution found.
       FEASIBLE = 2,
-      ///Optimal solution exists and found
+      /// = 3. Optimal solution exists and found.
       OPTIMAL = 3,
-      ///The cost function is unbounded
+      /// = 4. The cost function is unbounded.
       UNBOUNDED = 4
     };
@@ -1853,5 +1853,5 @@
     ///@}
 
-    ///\name Obtain the solution
+    ///\name Obtain the Solution
 
     ///@{
@@ -1975,15 +1975,14 @@
     /// The problem types for MIP problems
     enum ProblemType {
-      ///Feasible solution hasn't been found (but may exist).
+      /// = 0. Feasible solution hasn't been found (but may exist).
       UNDEFINED = 0,
-      ///The problem has no feasible solution
+      /// = 1. The problem has no feasible solution.
       INFEASIBLE = 1,
-      ///Feasible solution found
+      /// = 2. Feasible solution found.
       FEASIBLE = 2,
-      ///Optimal solution exists and found
+      /// = 3. Optimal solution exists and found.
       OPTIMAL = 3,
-      ///The cost function is unbounded
-      ///
-      ///The Mip or at least the relaxed problem is unbounded
+      /// = 4. The cost function is unbounded.
+      ///The Mip or at least the relaxed problem is unbounded.
       UNBOUNDED = 4
     };
@@ -2007,12 +2006,12 @@
     ///@}
 
-    ///\name Setting column type
+    ///\name Set Column Type
     ///@{
 
     ///Possible variable (column) types (e.g. real, integer, binary etc.)
     enum ColTypes {
-      ///Continuous variable (default)
+      /// = 0. Continuous variable (default).
       REAL = 0,
-      ///Integer variable
+      /// = 1. Integer variable.
       INTEGER = 1
     };
@@ -2035,5 +2034,5 @@
     ///@}
 
-    ///\name Obtain the solution
+    ///\name Obtain the Solution
 
     ///@{
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 619)
+++ lemon/maps.h	(revision 631)
@@ -2729,6 +2729,6 @@
   /// \brief Potential difference map
   ///
-  /// PotentialMap returns the difference between the potentials of the
-  /// source and target nodes of each arc in a digraph, i.e. it returns
+  /// PotentialDifferenceMap returns the difference between the potentials of
+  /// the source and target nodes of each arc in a digraph, i.e. it returns
   /// \code
   ///   potential[gr.target(arc)] - potential[gr.source(arc)].
Index: lemon/max_matching.h
===================================================================
--- lemon/max_matching.h	(revision 628)
+++ lemon/max_matching.h	(revision 637)
@@ -38,40 +38,49 @@
   /// \ingroup matching
   ///
-  /// \brief Edmonds' alternating forest maximum matching algorithm.
+  /// \brief Maximum cardinality matching in general graphs
   ///
-  /// This class implements Edmonds' alternating forest matching
-  /// algorithm. The algorithm can be started from an arbitrary initial
-  /// matching (the default is the empty one)
+  /// 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).
   ///
   /// The dual solution of the problem is a map of the nodes to
-  /// 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
+  /// \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
   /// 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 attained by calling \c
+  /// tight. This decomposition can be obtained by calling \c
   /// decomposition() after running the algorithm.
   ///
-  /// \param GR The graph type the algorithm runs on.
+  /// \tparam 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 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.
+    ///\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.
     enum Status {
-      EVEN = 1, D = 1, MATCHED = 0, C = 0, ODD = -1, A = -1, UNMATCHED = -2
+      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.
     };
 
@@ -339,6 +348,4 @@
     }
 
-
-
     void extendOnArc(const Arc& a) {
       Node base = _graph.source(a);
@@ -409,20 +416,17 @@
     }
 
-    /// \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 must call
-    /// \ref init(), \ref greedyInit() or \ref matchingInit()
-    /// functions first, then you can start the algorithm with the \ref
-    /// startSparse() or startDense() functions.
+    /// \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().
 
     ///@{
 
-    /// \brief Sets the actual matching to the empty matching.
-    ///
-    /// Sets the actual matching to the empty matching.
-    ///
+    /// \brief Set the initial matching to the empty matching.
+    ///
+    /// This function sets the initial matching to the empty matching.
     void init() {
       createStructures();
@@ -433,7 +437,7 @@
     }
 
-    ///\brief Finds an initial matching in a greedy way
-    ///
-    ///It finds an initial matching in a greedy way.
+    /// \brief Find an initial matching in a greedy way.
+    ///
+    /// This function finds an initial matching in a greedy way.
     void greedyInit() {
       createStructures();
@@ -459,9 +463,9 @@
 
 
-    /// \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.
+    /// \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.
     /// \return \c true if the map contains a matching.
     template <typename MatchingMap>
@@ -490,7 +494,10 @@
     }
 
-    /// \brief Starts Edmonds' algorithm
-    ///
-    /// If runs the original Edmonds' algorithm.
+    /// \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.
     void startSparse() {
       for(NodeIt n(_graph); n != INVALID; ++n) {
@@ -504,8 +511,12 @@
     }
 
-    /// \brief Starts Edmonds' algorithm.
-    ///
-    /// It runs Edmonds' algorithm with a heuristic of postponing
+    /// \brief Start Edmonds' algorithm with a heuristic improvement 
+    /// for dense graphs
+    ///
+    /// This function 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) {
@@ -520,9 +531,9 @@
 
 
-    /// \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.
+    /// \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).
     void run() {
       if (countEdges(_graph) < 2 * countNodes(_graph)) {
@@ -537,13 +548,13 @@
     /// @}
 
-    /// \name Primal solution
-    /// Functions to get the primal solution, ie. the matching.
+    /// \name Primal Solution
+    /// Functions to get the primal solution, i.e. the maximum matching.
 
     /// @{
 
-    ///\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.
+    /// \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.
     int matchingSize() const {
       int size = 0;
@@ -556,23 +567,25 @@
     }
 
-    /// \brief Returns true when the edge is in the matching.
-    ///
-    /// Returns true when the edge is in the matching.
+    /// \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.
     bool matching(const Edge& edge) const {
       return edge == (*_matching)[_graph.u(edge)];
     }
 
-    /// \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.
+    /// \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.
     Arc matching(const Node& n) const {
       return (*_matching)[n];
     }
 
-    ///\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.
+    /// \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.
     Node mate(const Node& n) const {
       return (*_matching)[n] != INVALID ?
@@ -582,21 +595,22 @@
     /// @}
 
-    /// \name Dual solution
-    /// Functions to get the dual solution, ie. the decomposition.
+    /// \name Dual Solution
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
+    /// decomposition.
 
     /// @{
 
-    /// \brief Returns the class of the node in the Edmonds-Gallai
+    /// \brief Return the status of the given node in the Edmonds-Gallai
     /// decomposition.
     ///
-    /// 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 Returns true when the node is in the barrier.
-    ///
-    /// Returns true when the node is in the barrier.
+    /// \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.
     bool barrier(const Node& n) const {
       return (*_status)[n] == ODD;
@@ -616,8 +630,8 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// 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.
+  /// 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.
   /// \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}
@@ -633,4 +647,5 @@
   /// 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] */
@@ -640,33 +655,40 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// 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".
+  /// 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
   template <typename GR,
             typename WM = typename GR::template EdgeMap<int> >
+#endif
   class MaxWeightedMatching {
   public:
 
-    ///\e
+    /// The graph type of the algorithm
     typedef GR Graph;
-    ///\e
+    /// The type of the edge weight map
     typedef WM WeightMap;
-    ///\e
+    /// The value type of the edge weights
     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:
@@ -1632,7 +1654,7 @@
     }
 
-    /// \name Execution control
+    /// \name Execution Control
     /// The simplest way to execute the algorithm is to use the
-    /// \c run() member function.
+    /// \ref run() member function.
 
     ///@{
@@ -1640,5 +1662,5 @@
     /// \brief Initialize the algorithm
     ///
-    /// Initialize the algorithm
+    /// This function initializes the algorithm.
     void init() {
       createStructures();
@@ -1692,7 +1714,9 @@
     }
 
-    /// \brief Starts the algorithm
-    ///
-    /// Starts the algorithm
+    /// \brief Start the algorithm
+    ///
+    /// This function starts the algorithm.
+    ///
+    /// \pre \ref init() must be called before using this function.
     void start() {
       enum OpType {
@@ -1777,7 +1801,7 @@
     }
 
-    /// \brief Runs %MaxWeightedMatching algorithm.
-    ///
-    /// This method runs the %MaxWeightedMatching algorithm.
+    /// \brief Run the algorithm.
+    ///
+    /// This method runs the \c %MaxWeightedMatching algorithm.
     ///
     /// \note mwm.run() is just a shortcut of the following code.
@@ -1793,12 +1817,17 @@
     /// @}
 
-    /// \name Primal solution
-    /// Functions to get the primal solution, ie. the matching.
+    /// \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.
 
     /// @{
 
-    /// \brief Returns the weight of the matching.
-    ///
-    /// Returns the weight of 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.
     Value matchingValue() const {
       Value sum = 0;
@@ -1811,7 +1840,9 @@
     }
 
-    /// \brief Returns the cardinality of the matching.
-    ///
-    /// Returns the cardinality of the matching.
+    /// \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.
     int matchingSize() const {
       int num = 0;
@@ -1824,23 +1855,31 @@
     }
 
-    /// \brief Returns true when the edge is in the matching.
-    ///
-    /// Returns true when the edge is in the matching.
+    /// \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.
     bool matching(const Edge& edge) const {
       return edge == (*_matching)[_graph.u(edge)];
     }
 
-    /// \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.
+    /// \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.
     Arc matching(const Node& node) const {
       return (*_matching)[node];
     }
 
-    /// \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.
+    /// \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.
     Node mate(const Node& node) const {
       return (*_matching)[node] != INVALID ?
@@ -1850,13 +1889,18 @@
     /// @}
 
-    /// \name Dual solution
-    /// Functions to get the dual solution.
+    /// \name Dual Solution
+    /// Functions to get the dual solution.\n
+    /// Either \ref run() or \ref start() function should be called before
+    /// using them.
 
     /// @{
 
-    /// \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".
+    /// \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.
     Value dualValue() const {
       Value sum = 0;
@@ -1870,14 +1914,18 @@
     }
 
-    /// \brief Returns the value of the node.
-    ///
-    /// Returns the the value of the node.
+    /// \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.
     Value nodeValue(const Node& n) const {
       return (*_node_potential)[n];
     }
 
-    /// \brief Returns the number of the blossoms in the basis.
-    ///
-    /// Returns the number of the blossoms in the basis.
+    /// \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.
     /// \see BlossomIt
     int blossomNum() const {
@@ -1885,25 +1933,29 @@
     }
 
-
-    /// \brief Returns the number of the nodes in the blossom.
-    ///
-    /// Returns the number of the nodes in the blossom.
+    /// \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
     int blossomSize(int k) const {
       return _blossom_potential[k].end - _blossom_potential[k].begin;
     }
 
-    /// \brief Returns the value of the blossom.
-    ///
-    /// Returns the the value of the blossom.
-    /// \see BlossomIt
+    /// \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.
     Value blossomValue(int k) const {
       return _blossom_potential[k].value;
     }
 
-    /// \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.
+    /// \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.
     class BlossomIt {
     public:
@@ -1911,5 +1963,9 @@
       /// \brief Constructor.
       ///
-      /// Constructor to get the nodes of the variable.
+      /// 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.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
         : _algorithm(&algorithm)
@@ -1919,7 +1975,7 @@
       }
 
-      /// \brief Conversion to node.
+      /// \brief Conversion to \c Node.
       ///
-      /// Conversion to node.
+      /// Conversion to \c Node.
       operator Node() const {
         return _algorithm->_blossom_node_list[_index];
@@ -1963,8 +2019,8 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// 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.
+  /// 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.
   /// \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}
@@ -1980,4 +2036,5 @@
   /// 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] */
@@ -1986,19 +2043,29 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// 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".
+  /// 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
   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;
 
@@ -2819,7 +2886,7 @@
     }
 
-    /// \name Execution control
+    /// \name Execution Control
     /// The simplest way to execute the algorithm is to use the
-    /// \c run() member function.
+    /// \ref run() member function.
 
     ///@{
@@ -2827,5 +2894,5 @@
     /// \brief Initialize the algorithm
     ///
-    /// Initialize the algorithm
+    /// This function initializes the algorithm.
     void init() {
       createStructures();
@@ -2875,7 +2942,9 @@
     }
 
-    /// \brief Starts the algorithm
-    ///
-    /// Starts the algorithm
+    /// \brief Start the algorithm
+    ///
+    /// This function starts the algorithm.
+    ///
+    /// \pre \ref init() must be called before using this function.
     bool start() {
       enum OpType {
@@ -2941,12 +3010,12 @@
     }
 
-    /// \brief Runs %MaxWeightedPerfectMatching algorithm.
-    ///
-    /// This method runs the %MaxWeightedPerfectMatching algorithm.
-    ///
-    /// \note mwm.run() is just a shortcut of the following code.
+    /// \brief Run the algorithm.
+    ///
+    /// This method runs the \c %MaxWeightedPerfectMatching algorithm.
+    ///
+    /// \note mwpm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwm.init();
-    ///   mwm.start();
+    ///   mwpm.init();
+    ///   mwpm.start();
     /// \endcode
     bool run() {
@@ -2957,12 +3026,17 @@
     /// @}
 
-    /// \name Primal solution
-    /// Functions to get the primal solution, ie. the matching.
+    /// \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.
 
     /// @{
 
-    /// \brief Returns the matching value.
-    ///
-    /// Returns the matching value.
+    /// \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.
     Value matchingValue() const {
       Value sum = 0;
@@ -2975,21 +3049,31 @@
     }
 
-    /// \brief Returns true when the edge is in the matching.
-    ///
-    /// Returns true when the edge is in the matching.
+    /// \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.
     bool matching(const Edge& edge) const {
       return static_cast<const Edge&>((*_matching)[_graph.u(edge)]) == edge;
     }
 
-    /// \brief Returns the incident matching edge.
-    ///
-    /// Returns the incident matching arc from given 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.
     Arc matching(const Node& node) const {
       return (*_matching)[node];
     }
 
-    /// \brief Returns the mate of the node.
-    ///
-    /// Returns the adjancent node in a mathcing arc.
+    /// \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.
     Node mate(const Node& node) const {
       return _graph.target((*_matching)[node]);
@@ -2998,13 +3082,18 @@
     /// @}
 
-    /// \name Dual solution
-    /// Functions to get the dual solution.
+    /// \name Dual Solution
+    /// Functions to get the dual solution.\n
+    /// Either \ref run() or \ref start() function should be called before
+    /// using them.
 
     /// @{
 
-    /// \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".
+    /// \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.
     Value dualValue() const {
       Value sum = 0;
@@ -3018,14 +3107,18 @@
     }
 
-    /// \brief Returns the value of the node.
-    ///
-    /// Returns the the value of the node.
+    /// \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.
     Value nodeValue(const Node& n) const {
       return (*_node_potential)[n];
     }
 
-    /// \brief Returns the number of the blossoms in the basis.
-    ///
-    /// Returns the number of the blossoms in the basis.
+    /// \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.
     /// \see BlossomIt
     int blossomNum() const {
@@ -3033,25 +3126,29 @@
     }
 
-
-    /// \brief Returns the number of the nodes in the blossom.
-    ///
-    /// Returns the number of the nodes in the blossom.
+    /// \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
     int blossomSize(int k) const {
       return _blossom_potential[k].end - _blossom_potential[k].begin;
     }
 
-    /// \brief Returns the value of the blossom.
-    ///
-    /// Returns the the value of the blossom.
-    /// \see BlossomIt
+    /// \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.
     Value blossomValue(int k) const {
       return _blossom_potential[k].value;
     }
 
-    /// \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.
+    /// \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.
     class BlossomIt {
     public:
@@ -3059,5 +3156,9 @@
       /// \brief Constructor.
       ///
-      /// Constructor to get the nodes of the variable.
+      /// 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.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
         : _algorithm(&algorithm)
@@ -3067,7 +3168,7 @@
       }
 
-      /// \brief Conversion to node.
+      /// \brief Conversion to \c Node.
       ///
-      /// Conversion to node.
+      /// Conversion to \c Node.
       operator Node() const {
         return _algorithm->_blossom_node_list[_index];
@@ -3084,10 +3185,10 @@
       /// \brief Validity checking
       ///
-      /// Checks whether the iterator is invalid.
+      /// This function checks whether the iterator is invalid.
       bool operator==(Invalid) const { return _index == _last; }
 
       /// \brief Validity checking
       ///
-      /// Checks whether the iterator is valid.
+      /// This function checks whether the iterator is valid.
       bool operator!=(Invalid) const { return _index != _last; }
 
@@ -3102,5 +3203,4 @@
   };
 
-
 } //END OF NAMESPACE LEMON
 
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 628)
+++ lemon/min_cost_arborescence.h	(revision 631)
@@ -91,8 +91,8 @@
   /// \ingroup spantree
   ///
-  /// \brief %MinCostArborescence algorithm class.
+  /// \brief Minimum Cost Arborescence algorithm class.
   ///
   /// This class provides an efficient implementation of
-  /// %MinCostArborescence algorithm. The arborescence is a tree
+  /// Minimum Cost Arborescence algorithm. The arborescence is a tree
   /// which is directed from a given source node of the digraph. One or
   /// more sources should be given for the algorithm and it will calculate
@@ -391,5 +391,5 @@
   public:
 
-    /// \name Named template parameters
+    /// \name Named Template Parameters
 
     /// @{
@@ -631,5 +631,5 @@
     /// @}
 
-    /// \name Execution control
+    /// \name Execution Control
     /// The simplest way to execute the algorithm is to use
     /// one of the member functions called \c run(...). \n
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 606)
+++ lemon/random.h	(revision 631)
@@ -660,5 +660,5 @@
     /// @}
 
-    ///\name Uniform distributions
+    ///\name Uniform Distributions
     ///
     /// @{
@@ -763,5 +763,5 @@
     /// @}
 
-    ///\name Non-uniform distributions
+    ///\name Non-uniform Distributions
     ///
     ///@{
@@ -939,5 +939,5 @@
     ///@}
 
-    ///\name Two dimensional distributions
+    ///\name Two Dimensional Distributions
     ///
     ///@{
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 606)
+++ lemon/suurballe.h	(revision 631)
@@ -289,5 +289,5 @@
     }
 
-    /// \name Execution control
+    /// \name Execution Control
     /// The simplest way to execute the algorithm is to call the run()
     /// function.
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 595)
+++ lemon/time_measure.h	(revision 631)
@@ -288,5 +288,5 @@
     Timer(bool run=true) :_running(run) {_reset();}
 
-    ///\name Control the state of the timer
+    ///\name Control the State of the Timer
     ///Basically a Timer can be either running or stopped,
     ///but it provides a bit finer control on the execution.
@@ -396,5 +396,5 @@
     ///@}
 
-    ///\name Query Functions for the ellapsed time
+    ///\name Query Functions for the Ellapsed Time
 
     ///@{
