Index: demo/hello_world.cc
===================================================================
--- demo/hello_world.cc	(revision 2391)
+++ demo/hello_world.cc	(revision 2408)
@@ -25,5 +25,5 @@
 /// \ref maps-page "maps". Click on the links to read more about these.
 ///
-/// \include hello_lemon.cc
+/// \include hello_world.cc
 
 #include <iostream>
Index: doc/algorithms.dox
===================================================================
--- doc/algorithms.dox	(revision 2391)
+++ doc/algorithms.dox	(revision 2408)
@@ -29,5 +29,5 @@
 \subsection Bfs
 The algorithm is implemented in the \ref lemon::Bfs "Bfs" template class - rather than as function.
-The class has two template parameters: \b GR and \TR.<br>
+The class has two template parameters: \b GR and \b TR.<br>
 GR is the graph the algorithm runs on. It has \ref lemon::ListGraph "ListGraph" as default type.
 TR is a Traits class commonly used to easy the parametrization of templates. In most cases you
@@ -52,5 +52,5 @@
 Now the distances and path information are stored in maps which you can access with
 member functions like \ref lemon::Bfs::distMap "distMap()" or \ref lemon::Bfs::predMap "predMap()".<br>
-Or more directly whit other member functions like \c predNode(). Once the algorithm
+Or more directly with other member functions like \ref lemon::Bfs::predNode "predNode()". Once the algorithm
 is finished (or to be precise reached that node) \ref lemon::Bfs::dist "dist()" or \ref lemon::Bfs::predNode
 "predNode()" can be called.
@@ -116,5 +116,5 @@
 \until };
 The class meets the \ref lemon::WriteMap "WriteMap" concept. In it's \c set() method the only thing
-we need to do is insert the key - that is the node who's processing just finished - into the beginning
+we need to do is insert the key - that is the node whose processing just finished - into the beginning
 of the list.<br>
 Although we implemented this needed helper class ourselves it was not necessary.
Index: doc/getting_started.dox
===================================================================
--- doc/getting_started.dox	(revision 2391)
+++ doc/getting_started.dox	(revision 2408)
@@ -77,5 +77,5 @@
 In the next few lines we add some more nodes and edges and to the graph we need.
 Those lines are not very interesting so we skip them, but you find the whole
-working program in file hello_lemon.cc in the demo section.
+working program in file hello_world.cc in the demo section.
 
 The next statement must be familiar. But what is that INVALID in the \c while
Index: doc/maps1.dox
===================================================================
--- doc/maps1.dox	(revision 2391)
+++ doc/maps1.dox	(revision 2408)
@@ -35,5 +35,5 @@
 To make easy to use them - especially as template parameters - there are <i>map concepts</i> like by graph classes.
 <ul>
-<li>\ref ReadMap - values can be red out with the \c operator[].
+<li>\ref ReadMap - values can be read out with the \c operator[].
 \code value_typed_variable = map_instance[key_value]; \endcode
 </li>
@@ -60,5 +60,5 @@
 type. As an example, think of a edge-weighted directed graph.
 \code ListGraph::EdgeMap<int>  weight(graph); \endcode
-You can see that the map needs the graph hows edges will mapped, but nothing more.
+You can see that the map needs the graph whose edges will mapped, but nothing more.
 
 If the graph class is extendable or erasable the map will automatically follow
Index: doc/maps2.dox
===================================================================
--- doc/maps2.dox	(revision 2391)
+++ doc/maps2.dox	(revision 2408)
@@ -43,5 +43,5 @@
   typedef double Value;
   typedef Graph::Edge Key;
-  double operator[](Key e) const { return M_PI;}
+  double operator[](const Key &e) const { return M_PI;}
 };
 \endcode
@@ -52,5 +52,5 @@
 struct MyMap : public MapBase<Graph::Edge,double>
 {
-  Value operator[](Key e) const { return M_PI;}
+  Value operator[](const Key& e) const { return M_PI;}
 };
 \endcode
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 2394)
+++ lemon/bellman_ford.h	(revision 2408)
@@ -39,5 +39,5 @@
   ///  
   /// It defines all computational operations and constants which are
-  /// used in the bellman ford algorithm. The default implementation
+  /// used in the Bellman-Ford algorithm. The default implementation
   /// is based on the numeric_limits class. If the numeric type does not
   /// have infinity value then the maximum value is used as extremal
@@ -101,5 +101,5 @@
     typedef typename _LengthMap::Value Value;
 
-    /// \brief Operation traits for bellman-ford algorithm.
+    /// \brief Operation traits for Bellman-Ford algorithm.
     ///
     /// It defines the infinity type on the given Value type
@@ -411,6 +411,7 @@
     /// \brief Adds a new source node.
     ///
-    /// The optional second parameter is the initial distance of the node.
-    /// It just sets the distance of the node to the given value.
+    /// Adds a new source node. The optional second parameter is the 
+    /// initial distance of the node. It just sets the distance of the 
+    /// node to the given value.
     void addSource(Node source, Value dst = OperationTraits::zero()) {
       _dist->set(source, dst);
@@ -421,5 +422,5 @@
     }
 
-    /// \brief Executes one round from the bellman ford algorithm.
+    /// \brief Executes one round from the Bellman-Ford algorithm.
     ///
     /// If the algoritm calculated the distances in the previous round
@@ -464,5 +465,5 @@
     }
 
-    /// \brief Executes one weak round from the bellman ford algorithm.
+    /// \brief Executes one weak round from the Bellman-Ford algorithm.
     ///
     /// If the algorithm calculated the distances in the
@@ -518,5 +519,5 @@
     /// \pre init() must be called and at least one node should be added
     /// with addSource() before using this function. If there is
-    /// a negative cycles in the graph it gives back false.
+    /// a negative cycle in the graph it gives back false.
     ///
     /// This method runs the %BellmanFord algorithm from the root node(s)
@@ -608,5 +609,5 @@
     ///@{
 
-    /// \brief Lemon iterator for get a active nodes.
+    /// \brief Lemon iterator for get the active nodes.
     ///
     /// Lemon iterator for get the active nodes. This class provides a
@@ -785,5 +786,5 @@
     typedef typename _LengthMap::Value Value;
 
-    /// \brief Operation traits for bellman-ford algorithm.
+    /// \brief Operation traits for Bellman-Ford algorithm.
     ///
     /// It defines the infinity type on the given Value type
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 2391)
+++ lemon/circulation.h	(revision 2408)
@@ -131,7 +131,7 @@
     bool checkX() { return checkX(_x); }
 
-    ///Chech if \c bar is a real barrier
-
-    ///Chech if \c bar is a real barrier
+    ///Check if \c bar is a real barrier
+
+    ///Check if \c bar is a real barrier
     ///\sa barrier()
     template<class GT>
@@ -151,7 +151,7 @@
       return _tol.negative(delta);
     }  
-    ///Chech whether or not the last execution provides a barrier
-
-    ///Chech whether or not the last execution provides a barrier
+    ///Check whether or not the last execution provides a barrier
+
+    ///Check whether or not the last execution provides a barrier
     ///\sa barrier()
     bool checkBarrier() 
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 2392)
+++ lemon/graph_adaptor.h	(revision 2408)
@@ -1497,5 +1497,5 @@
   ///\endcode 
   ///
-  ///Then RevGraphAdaptor implements the graph structure with node-set
+  ///Then ResGraphAdaptor implements the graph structure with node-set
   /// \f$ V \f$ and edge-set \f$ A_{forward}\cup A_{backward} \f$,
   ///where \f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$ and 
Index: lemon/ssp_min_cost_flow.h
===================================================================
--- lemon/ssp_min_cost_flow.h	(revision 2396)
+++ lemon/ssp_min_cost_flow.h	(revision 2408)
@@ -189,6 +189,5 @@
     }
 
-    /// \brief The class is reset to zero flow and potential. The
-    /// class is reset to zero flow and potential.
+    /// \brief The class is reset to zero flow and potential.
     void reset() {
       total_length=0;
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 2391)
+++ lemon/time_measure.h	(revision 2408)
@@ -234,22 +234,22 @@
   ///It is quite easy-to-use, here is a short example.
   ///\code
-  ///#include<lemon/time_measure.h>
-  ///#include<iostream>
-  ///
-  ///int main()
-  ///{
-  ///
-  ///  ...
-  ///
-  ///  Timer T;
-  ///  doSomething();
-  ///  std::cout << T << '\n';
-  ///  T.restart();
-  ///  doSomethingElse();
-  ///  std::cout << T << '\n';
-  ///
-  ///  ...
-  ///
-  ///}
+  /// #include<lemon/time_measure.h>
+  /// #include<iostream>
+  ///
+  /// int main()
+  /// {
+  ///
+  ///   ...
+  ///
+  ///   Timer T;
+  ///   doSomething();
+  ///   std::cout << T << '\n';
+  ///   T.restart();
+  ///   doSomethingElse();
+  ///   std::cout << T << '\n';
+  ///
+  ///   ...
+  ///
+  /// }
   ///\endcode
   ///
