Index: lemon/base.cc
===================================================================
--- lemon/base.cc	(revision 7)
+++ lemon/base.cc	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -18,5 +18,5 @@
 
 ///\file
-///\brief Some basic non inline function and static global data.
+///\brief Some basic non-inline functions and static global data.
 
 #include<lemon/tolerance.h>
Index: lemon/bits/invalid.h
===================================================================
--- lemon/bits/invalid.h	(revision 13)
+++ lemon/bits/invalid.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,4 +27,5 @@
   /// \brief Dummy type to make it easier to create invalid iterators.
   ///
+  /// Dummy type to make it easier to create invalid iterators.
   /// See \ref INVALID for the usage.
   struct Invalid {
Index: lemon/bits/utility.h
===================================================================
--- lemon/bits/utility.h	(revision 7)
+++ lemon/bits/utility.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concept_check.h
===================================================================
--- lemon/concept_check.h	(revision 27)
+++ lemon/concept_check.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 48)
+++ lemon/concepts/maps.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -49,5 +49,4 @@
       /// Returns the value associated with a key.
 
-      /// Returns the value associated with a key.
       /// \bug Value shouldn't need to be default constructible.
       ///
@@ -115,5 +114,5 @@
     };
 
-    /// Read/writable map concept
+    /// Read/Writable map concept
     
     /// Read/writable map concept.
@@ -148,5 +147,4 @@
     /// Dereferable map concept.
     ///
-    /// \todo Rethink this concept.
     template<typename K, typename T, typename R, typename CR>
     class ReferenceMap : public ReadWriteMap<K,T>
@@ -168,11 +166,12 @@
     public:
 
-      ///Returns a reference to the value associated with a key.
+      ///Returns a reference to the value associated to a key.
       Reference operator[](const Key &) { return tmp; }
-      ///Returns a const reference to the value associated with a key.
+      ///Returns a const reference to the value associated to a key.
       ConstReference operator[](const Key &) const { return tmp; }
       /// Sets the value associated with a key.
       void set(const Key &k,const Value &t) { operator[](k)=t; }
 
+      /// \todo Rethink this concept. 
       template<typename _ReferenceMap>
       struct ReferenceMapConcept {
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 15)
+++ lemon/dim2.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,6 +28,5 @@
 ///
 /// The class \ref lemon::dim2::Point "dim2::Point" implements
-///a two dimensional vector with the usual
-/// operations.
+/// a two dimensional vector with the usual operations.
 ///
 /// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
@@ -50,7 +49,5 @@
 
   /// A simple two dimensional vector (plainvector) implementation
-  ///with the usual vector
-  /// operators.
-  ///
+  /// with the usual vector operations.
   template<typename T>
     class Point {
@@ -71,5 +68,5 @@
       Point(T a, T b) : x(a), y(b) { }
 
-      ///The dimension of the vector.
+      ///Returns the dimension of the vector (i.e. returns 2).
 
       ///The dimension of the vector.
@@ -97,5 +94,5 @@
       }
   
-      ///Increment the left hand side by u
+      ///Increment the left hand side by \c u
       Point<T>& operator +=(const Point<T>& u) {
         x += u.x;
@@ -104,5 +101,5 @@
       }
   
-      ///Decrement the left hand side by u
+      ///Decrement the left hand side by \c u
       Point<T>& operator -=(const Point<T>& u) {
         x -= u.x;
@@ -316,4 +313,5 @@
       ///if at least one point was added to the box or the coordinates of
       ///the box were set).
+      ///
       ///The coordinates of an empty bounding box are not defined. 
       bool empty() const {
@@ -326,7 +324,7 @@
       }
 
-      ///Give back the bottom left corner
-
-      ///Give back the bottom left corner.
+      ///Give back the bottom left corner of the box
+
+      ///Give back the bottom left corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomLeft() const {
@@ -334,7 +332,7 @@
       }
 
-      ///Set the bottom left corner
-
-      ///Set the bottom left corner.
+      ///Set the bottom left corner of the box
+
+      ///Set the bottom left corner of the box.
       ///It should only be used for non-empty box.
       void bottomLeft(Point<T> p) {
@@ -342,7 +340,7 @@
       }
 
-      ///Give back the top right corner
-
-      ///Give back the top right corner.
+      ///Give back the top right corner of the box
+
+      ///Give back the top right corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> topRight() const {
@@ -350,7 +348,7 @@
       }
 
-      ///Set the top right corner
-
-      ///Set the top right corner.
+      ///Set the top right corner of the box
+
+      ///Set the top right corner of the box.
       ///It should only be used for non-empty box.
       void topRight(Point<T> p) {
@@ -358,7 +356,7 @@
       }
 
-      ///Give back the bottom right corner
-
-      ///Give back the bottom right corner.
+      ///Give back the bottom right corner of the box
+
+      ///Give back the bottom right corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomRight() const {
@@ -366,7 +364,7 @@
       }
 
-      ///Set the bottom right corner
-
-      ///Set the bottom right corner.
+      ///Set the bottom right corner of the box
+
+      ///Set the bottom right corner of the box.
       ///It should only be used for non-empty box.
       void bottomRight(Point<T> p) {
@@ -375,7 +373,7 @@
       }
  
-      ///Give back the top left corner
-
-      ///Give back the top left corner.
+      ///Give back the top left corner of the box
+
+      ///Give back the top left corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> topLeft() const {
@@ -383,7 +381,7 @@
       }
 
-      ///Set the top left corner
-
-      ///Set the top left corner.
+      ///Set the top left corner of the box
+
+      ///Set the top left corner of the box.
       ///It should only be used for non-empty box.
       void topLeft(Point<T> p) {
@@ -669,11 +667,10 @@
 
 
-    ///\brief Map of the \ref Point::normSquare() "normSquare()"
-    ///of a \ref Point "Point"-map
-    ///
-    ///Map of the \ref Point::normSquare() "normSquare()"
-    ///of a \ref Point "Point"-map.
-    ///\ingroup maps
-    ///
+  ///\brief Map of the \ref Point::normSquare() "normSquare()"
+  ///of a \ref Point "Point"-map
+  ///
+  ///Map of the \ref Point::normSquare() "normSquare()"
+  ///of a \ref Point "Point"-map.
+  ///\ingroup maps
   template<class M>
   class NormSquareMap 
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 2)
+++ lemon/list_graph.h	(revision 39)
@@ -0,0 +1,18 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 47)
+++ lemon/maps.h	(revision 44)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,7 +82,6 @@
   /// Constant map.
 
-  /// This is a \ref concepts::ReadMap "readable" map which assigns a 
-  /// specified value to each key.
-  /// In other aspects it is equivalent to \c NullMap.
+  /// This is a readable map which assigns a specified value to each key.
+  /// In other aspects it is equivalent to the \c NullMap.
   template<typename K, typename T>
   class ConstMap : public MapBase<K, T> {
@@ -135,7 +134,6 @@
   /// Constant map with inlined constant value.
 
-  /// This is a \ref concepts::ReadMap "readable" map which assigns a 
-  /// specified value to each key.
-  /// In other aspects it is equivalent to \c NullMap.
+  /// This is a readable map which assigns a specified value to each key.
+  /// In other aspects it is equivalent to the \c NullMap.
   template<typename K, typename V, V v>
   class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
@@ -152,5 +150,5 @@
   };
 
-  ///Returns a \c ConstMap class with inlined value
+  ///Returns a \c ConstMap class
 
   ///This function just returns a \c ConstMap class with inlined value.
@@ -161,26 +159,23 @@
   }
 
-  ///Map based on \c std::map
+  ///Map based on std::map
 
   ///This is essentially a wrapper for \c std::map with addition that
   ///you can specify a default value different from \c Value().
-  ///It meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
   template <typename K, typename T, typename Compare = std::less<K> >
-  class StdMap : public MapBase<K, T> {
+  class StdMap {
     template <typename K1, typename T1, typename C1>
     friend class StdMap;
   public:
 
-    typedef MapBase<K, T> Parent;
-    ///\e
-    typedef typename Parent::Key Key;
-    ///\e
-    typedef typename Parent::Value Value;
-    ///\e
+    typedef True ReferenceMapTag;
+    ///Key type
+    typedef K Key;
+    ///Value type
+    typedef T Value;
+    ///Reference Type
     typedef T& Reference;
-    ///\e
+    ///Const reference type
     typedef const T& ConstReference;
-
-    typedef True ReferenceMapTag;
 
   private:
@@ -194,11 +189,11 @@
     /// Constructor with specified default value
     StdMap(const T& value = T()) : _value(value) {}
-    /// \brief Constructs the map from an appropriate \c std::map, and 
-    /// explicitly specifies a default value.
+    /// \brief Constructs the map from an appropriate std::map, and explicitly
+    /// specifies a default value.
     template <typename T1, typename Comp1>
     StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T()) 
       : _map(map.begin(), map.end()), _value(value) {}
     
-    /// \brief Constructs a map from an other \ref StdMap.
+    /// \brief Constructs a map from an other StdMap.
     template<typename T1, typename Comp1>
     StdMap(const StdMap<Key, T1, Comp1> &c) 
@@ -245,37 +240,15 @@
 
   };
-  
-  ///Returns a \c StdMap class
-
-  ///This function just returns a \c StdMap class with specified 
-  ///default value.
-  ///\relates StdMap
-  template<typename K, typename V, typename Compare = std::less<K> > 
-  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
-    return StdMap<K, V, Compare>(value);
-  }
-
-  ///Returns a \c StdMap class created from an appropriate std::map
-
-  ///This function just returns a \c StdMap class created from an 
-  ///appropriate std::map.
-  ///\relates StdMap
-  template<typename K, typename V, typename Compare = std::less<K> > 
-  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, 
-                                       const V& value = V() ) {
-    return StdMap<K, V, Compare>(map, value);
-  }
 
   /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
   ///
-  /// This map has the <tt>[0..size-1]</tt> keyset and the values
+  /// The current map has the <tt>[0..size-1]</tt> keyset and the values
   /// are stored in a \c std::vector<T>  container. It can be used with
   /// some data structures, for example \c UnionFind, \c BinHeap, when 
-  /// the used items are small integer numbers.
-  /// This map meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
+  /// the used items are small integer numbers. 
   ///
   /// \todo Revise its name
   template <typename T>
-  class IntegerMap : public MapBase<int, T> {
+  class IntegerMap {
 
     template <typename T1>
@@ -284,15 +257,13 @@
   public:
 
-    typedef MapBase<int, T> Parent;
-    ///\e
-    typedef typename Parent::Key Key;
-    ///\e
-    typedef typename Parent::Value Value;
+    typedef True ReferenceMapTag;
+    ///\e
+    typedef int Key;
+    ///\e
+    typedef T Value;
     ///\e
     typedef T& Reference;
     ///\e
     typedef const T& ConstReference;
-
-    typedef True ReferenceMapTag;
 
   private:
@@ -306,10 +277,10 @@
     IntegerMap(int size = 0, const T& value = T()) : _vector(size, value) {}
 
-    /// \brief Constructs the map from an appropriate \c std::vector.
+    /// \brief Constructs the map from an appropriate std::vector.
     template <typename T1>
     IntegerMap(const std::vector<T1>& vector) 
       : _vector(vector.begin(), vector.end()) {}
     
-    /// \brief Constructs a map from an other \ref IntegerMap.
+    /// \brief Constructs a map from an other IntegerMap.
     template <typename T1>
     IntegerMap(const IntegerMap<T1> &c) 
@@ -343,13 +314,4 @@
 
   };
-  
-  ///Returns an \c IntegerMap class
-
-  ///This function just returns an \c IntegerMap class.
-  ///\relates IntegerMap
-  template<typename T>
-  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
-    return IntegerMap<T>(size, value);
-  }
 
   /// @}
@@ -388,5 +350,5 @@
   ///the default conversion.
   ///
-  ///This \ref concepts::ReadMap "read only map"
+  ///This \c concepts::ReadMap "read only map"
   ///converts the \c Value of a map to type \c T.
   ///Its \c Key is inherited from \c M.
@@ -405,5 +367,7 @@
     ConvertMap(const M &_m) : m(_m) {};
 
-    ///\e
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
     Value operator[](const Key& k) const {return m[k];}
   };
@@ -442,17 +406,8 @@
     Value operator[](Key k) const {return m[k];}
   };
-  
-  ///Returns a \c SimpleMap class
-
-  ///This function just returns a \c SimpleMap class.
-  ///\relates SimpleMap
-  template<typename M>
-  inline SimpleMap<M> simpleMap(const M &m) {
-    return SimpleMap<M>(m);
-  }
 
   ///Simple writable wrapping of a map
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the simple
+  ///This \ref concepts::WriteMap "write map" returns the simple
   ///wrapping of the given map. Sometimes the reference maps cannot be
   ///combined with simple read-write maps. This map adaptor wraps the
@@ -479,19 +434,10 @@
   };
 
-  ///Returns a \c SimpleWriteMap class
-
-  ///This function just returns a \c SimpleWriteMap class.
-  ///\relates SimpleWriteMap
-  template<typename M>
-  inline SimpleWriteMap<M> simpleWriteMap(M &m) {
-    return SimpleWriteMap<M>(m);
-  }
-
   ///Sum of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the sum of the two
+  ///This \c concepts::ReadMap "read only map" returns the sum of the two
   ///given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
-  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
+  ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
   template<typename M1, typename M2> 
   class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -513,5 +459,5 @@
 
   ///This function just returns an \c AddMap class.
-  ///\todo Extend the documentation: how to call these type of functions?
+  ///\todo How to call these type of functions?
   ///
   ///\relates AddMap
@@ -523,5 +469,5 @@
   ///Shift a map with a constant.
 
-  ///This \ref concepts::ReadMap "read only map" returns the sum of the
+  ///This \c concepts::ReadMap "read only map" returns the sum of the
   ///given map and a constant value.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -559,5 +505,5 @@
   ///Shift a map with a constant (ReadWrite version).
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
+  ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the
   ///given map and a constant value. It makes also possible to write the map.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -605,5 +551,5 @@
   ///Difference of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the difference
+  ///This \c concepts::ReadMap "read only map" returns the difference
   ///of the values of the two given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
@@ -638,5 +584,5 @@
   ///Product of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the product of the
+  ///This \c concepts::ReadMap "read only map" returns the product of the
   ///values of the two given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
@@ -668,5 +614,5 @@
   ///Scales a map with a constant.
 
-  ///This \ref concepts::ReadMap "read only map" returns the value of the
+  ///This \c concepts::ReadMap "read only map" returns the value of the
   ///given map multiplied from the left side with a constant value.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -704,5 +650,5 @@
   ///Scales a map with a constant (ReadWrite version).
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
+  ///This \c concepts::ReadWriteMap "read-write map" returns the value of the
   ///given map multiplied from the left side with a constant value. It can
   ///also be used as write map if the \c / operator is defined between
@@ -752,5 +698,5 @@
   ///Quotient of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the quotient of the
+  ///This \c concepts::ReadMap "read only map" returns the quotient of the
   ///values of the two given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
@@ -782,5 +728,5 @@
   ///Composition of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the composition of
+  ///This \c concepts::ReadMap "read only map" returns the composition of
   ///two given maps.
   ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,
@@ -833,5 +779,5 @@
   ///Combine of two maps using an STL (binary) functor.
   ///
-  ///This \ref concepts::ReadMap "read only map" takes two maps and a
+  ///This \c concepts::ReadMap "read only map" takes two maps and a
   ///binary functor and returns the composition of the two
   ///given maps unsing the functor. 
@@ -906,5 +852,5 @@
   ///Negative value of a map
 
-  ///This \ref concepts::ReadMap "read only map" returns the negative
+  ///This \c concepts::ReadMap "read only map" returns the negative
   ///value of the value returned by the given map.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -928,5 +874,5 @@
   ///Negative value of a map (ReadWrite version)
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the negative
+  ///This \c concepts::ReadWriteMap "read-write map" returns the negative
   ///value of the value returned by the given map.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -970,5 +916,5 @@
   ///Absolute value of a map
 
-  ///This \ref concepts::ReadMap "read only map" returns the absolute value
+  ///This \c concepts::ReadMap "read only map" returns the absolute value
   ///of the value returned by the given map.
   ///Its \c Key and \c Value are inherited from \c M. 
@@ -1004,5 +950,5 @@
   ///Converts an STL style functor to a map
 
-  ///This \ref concepts::ReadMap "read only map" returns the value
+  ///This \c concepts::ReadMap "read only map" returns the value
   ///of a given functor.
   ///
@@ -1010,6 +956,5 @@
   ///\c Key and \c Value. 
   ///In most cases they have to be given explicitly because a 
-  ///functor typically does not provide \c argument_type and 
-  ///\c result_type typedefs.
+  ///functor typically does not provide such typedefs.
   ///
   ///Parameter \c F is the type of the used functor.
@@ -1036,7 +981,6 @@
   ///This function just returns a \c FunctorMap class.
   ///
-  ///This function is specialized for adaptable binary function
-  ///classes and C++ functions.
-  ///
+  ///It is specialized for adaptable function classes and
+  ///C++ functions.
   ///\relates FunctorMap
   template<typename K, typename V, typename F> inline 
@@ -1061,8 +1005,8 @@
 
   ///This class Converts a map to an STL style (unary) functor.
-  ///That is it provides an <tt>operator()</tt> to read its values.
+  ///that is it provides an <tt>operator()</tt> to read its values.
   ///
   ///For the sake of convenience it also works as
-  ///a ususal \ref concepts::ReadMap "readable map",
+  ///a ususal \c concepts::ReadMap "readable map",
   ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
   ///
@@ -1096,12 +1040,12 @@
   }
 
-  ///Just readable version of \ref ForkWriteMap
-
-  ///This map has two \ref concepts::ReadMap "readable map"
+  ///Applies all map setting operations to two maps
+
+  ///This map has two \c concepts::ReadMap "readable map"
   ///parameters and each read request will be passed just to the
-  ///first map. This class is the just readable map type of \c ForkWriteMap.
+  ///first map. This class is the just readable map type of the ForkWriteMap.
   ///
   ///The \c Key and \c Value are inherited from \c M1.
-  ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
+  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
   ///
   ///\sa ForkWriteMap
@@ -1126,12 +1070,12 @@
   ///Applies all map setting operations to two maps
 
-  ///This map has two \ref concepts::WriteMap "writable map"
+  ///This map has two \c concepts::WriteMap "writable map"
   ///parameters and each write request will be passed to both of them.
-  ///If \c M1 is also \ref concepts::ReadMap "readable",
+  ///If \c M1 is also \c concepts::ReadMap "readable",
   ///then the read operations will return the
   ///corresponding values of \c M1.
   ///
   ///The \c Key and \c Value are inherited from \c M1.
-  ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
+  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
   ///
   ///\sa ForkMap
@@ -1177,7 +1121,7 @@
   ///Logical 'not' of a map
   
-  ///This bool \ref concepts::ReadMap "read only map" returns the 
+  ///This bool \c concepts::ReadMap "read only map" returns the 
   ///logical negation of the value returned by the given map.
-  ///Its \c Key is inherited from \c M, its \c Value is \c bool.
+  ///Its \c Key is inherited from \c M, its Value is \c bool.
   ///
   ///\sa NotWriteMap
@@ -1198,8 +1142,8 @@
   ///Logical 'not' of a map (ReadWrie version)
   
-  ///This bool \ref concepts::ReadWriteMap "read-write map" returns the 
+  ///This bool \c concepts::ReadWriteMap "read-write map" returns the 
   ///logical negation of the value returned by the given map. When it is set,
   ///the opposite value is set to the original map.
-  ///Its \c Key is inherited from \c M, its \c Value is \c bool.
+  ///Its \c Key is inherited from \c M, its Value is \c bool.
   ///
   ///\sa NotMap
@@ -1266,13 +1210,13 @@
   /// \brief Writable bool map for logging each \c true assigned element
   ///
-  /// A \ref concepts::ReadWriteMap "read-write" bool map for logging 
-  /// each \c true assigned element, i.e it copies all the keys set 
-  /// to \c true to the given iterator.
+  /// Writable bool map for logging each \c true assigned element, i.e it
+  /// copies all the keys set to \c true to the given iterator.
   ///
   /// \note The container of the iterator should contain space 
   /// for each element.
   ///
-  /// The following example shows how you can write the edges found by 
-  /// the \ref Prim algorithm directly to the standard output.
+  /// The following example shows how you can write the edges found by the Prim
+  /// algorithm directly
+  /// to the standard output.
   ///\code
   /// typedef IdMap<Graph, Edge> EdgeIdMap;
Index: lemon/random.cc
===================================================================
--- lemon/random.cc	(revision 16)
+++ lemon/random.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 23)
+++ lemon/random.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -511,5 +511,5 @@
   ///\endcode
   ///
-  /// The lemon provides a global instance of the random number
+  /// LEMON provides a global instance of the random number
   /// generator which name is \ref lemon::rnd "rnd". Usually it is a
   /// good programming convenience to use this global generator to get
@@ -527,10 +527,10 @@
   public:
 
-    /// \brief Constructor
+    /// \brief Default constructor
     ///
     /// Constructor with constant seeding.
     Random() { core.initState(); }
 
-    /// \brief Constructor
+    /// \brief Constructor with seed
     ///
     /// Constructor with seed. The current number type will be converted
@@ -541,5 +541,5 @@
     }
 
-    /// \brief Constructor
+    /// \brief Constructor with array seeding
     ///
     /// Constructor with array seeding. The given range should contain
@@ -578,5 +578,5 @@
     ///
     /// It returns a random real number from the range [0, 1). The
-    /// default Number type is double.
+    /// default Number type is \c double.
     template <typename Number>
     Number real() {
@@ -654,6 +654,6 @@
     ///
     /// It returns a random non-negative integer uniformly from the
-    /// whole range of the current \c Number type.  The default result
-    /// type of this function is unsigned int.
+    /// whole range of the current \c Number type. The default result
+    /// type of this function is <tt>unsigned int</tt>.
     template <typename Number>
     Number uinteger() {
@@ -669,5 +669,5 @@
     /// It returns a random integer uniformly from the whole range of
     /// the current \c Number type. The default result type of this
-    /// function is int.
+    /// function is \c int.
     template <typename Number>
     Number integer() {
@@ -690,5 +690,5 @@
     }
 
-    ///\name Nonuniform distributions
+    ///\name Non-uniform distributions
     ///
     
Index: lemon/tolerance.h
===================================================================
--- lemon/tolerance.h	(revision 16)
+++ lemon/tolerance.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -37,10 +37,10 @@
   ///as a result of a probably inexact computation.
   ///
-  ///Tolerance is a class to provide a basic way to
+  ///\ref Tolerance is a class to provide a basic way to
   ///handle the comparison of numbers that are obtained
   ///as a result of a probably inexact computation.
   ///
   ///This is an abstract class, it should be specialized for all numerical
-  ///data types. These specialized classes like \ref Tolerance\<double\>
+  ///data types. These specialized classes like \ref Tolerance<double>
   ///may offer additional tuning parameters.
   ///
@@ -49,11 +49,7 @@
   ///\sa Tolerance<long double>
   ///\sa Tolerance<int>
-#if defined __GNUC__ && !defined __STRICT_ANSI__  
   ///\sa Tolerance<long long int>
-#endif
   ///\sa Tolerance<unsigned int>
-#if defined __GNUC__ && !defined __STRICT_ANSI__  
   ///\sa Tolerance<unsigned long long int>
-#endif
 
   template<class T>
@@ -64,5 +60,5 @@
 
     ///\name Comparisons
-    ///The concept is that these bool functions return with \c true only if
+    ///The concept is that these bool functions return \c true only if
     ///the related comparisons hold even if some numerical error appeared
     ///during the computations.
@@ -92,7 +88,7 @@
 
 
-  ///Float specialization of \ref Tolerance.
-
-  ///Float specialization of \ref Tolerance.
+  ///Float specialization of Tolerance.
+
+  ///Float specialization of Tolerance.
   ///\sa Tolerance
   ///\relates Tolerance
@@ -108,19 +104,19 @@
     ///Constructor setting the epsilon tolerance to the default value.
     Tolerance() : _epsilon(def_epsilon) {}
-    ///Constructor setting the epsilon tolerance.
+    ///Constructor setting the epsilon tolerance to the given value.
     Tolerance(float e) : _epsilon(e) {}
 
-    ///Return the epsilon value.
+    ///Returns the epsilon value.
     Value epsilon() const {return _epsilon;}
-    ///Set the epsilon value.
+    ///Sets the epsilon value.
     void epsilon(Value e) {_epsilon=e;}
 
-    ///Return the default epsilon value.
+    ///Returns the default epsilon value.
     static Value defaultEpsilon() {return def_epsilon;}
-    ///Set the default epsilon value.
+    ///Sets the default epsilon value.
     static void defaultEpsilon(Value e) {def_epsilon=e;}
 
     ///\name Comparisons
-    ///See class Tolerance for more details.
+    ///See \ref Tolerance for more details.
 
     ///@{
@@ -143,7 +139,7 @@
   };
 
-  ///Double specialization of \ref Tolerance.
-
-  ///Double specialization of \ref Tolerance.
+  ///Double specialization of Tolerance.
+
+  ///Double specialization of Tolerance.
   ///\sa Tolerance
   ///\relates Tolerance
@@ -159,19 +155,19 @@
     ///Constructor setting the epsilon tolerance to the default value.
     Tolerance() : _epsilon(def_epsilon) {}
-    ///Constructor setting the epsilon tolerance.
+    ///Constructor setting the epsilon tolerance to the given value.
     Tolerance(double e) : _epsilon(e) {}
 
-    ///Return the epsilon value.
+    ///Returns the epsilon value.
     Value epsilon() const {return _epsilon;}
-    ///Set the epsilon value.
+    ///Sets the epsilon value.
     void epsilon(Value e) {_epsilon=e;}
 
-    ///Return the default epsilon value.
+    ///Returns the default epsilon value.
     static Value defaultEpsilon() {return def_epsilon;}
-    ///Set the default epsilon value.
+    ///Sets the default epsilon value.
     static void defaultEpsilon(Value e) {def_epsilon=e;}
 
     ///\name Comparisons
-    ///See class Tolerance for more details.
+    ///See \ref Tolerance for more details.
 
     ///@{
@@ -194,7 +190,7 @@
   };
 
-  ///Long double specialization of \ref Tolerance.
-
-  ///Long double specialization of \ref Tolerance.
+  ///Long double specialization of Tolerance.
+
+  ///Long double specialization of Tolerance.
   ///\sa Tolerance
   ///\relates Tolerance
@@ -210,19 +206,19 @@
     ///Constructor setting the epsilon tolerance to the default value.
     Tolerance() : _epsilon(def_epsilon) {}
-    ///Constructor setting the epsilon tolerance.
+    ///Constructor setting the epsilon tolerance to the given value.
     Tolerance(long double e) : _epsilon(e) {}
 
-    ///Return the epsilon value.
+    ///Returns the epsilon value.
     Value epsilon() const {return _epsilon;}
-    ///Set the epsilon value.
+    ///Sets the epsilon value.
     void epsilon(Value e) {_epsilon=e;}
 
-    ///Return the default epsilon value.
+    ///Returns the default epsilon value.
     static Value defaultEpsilon() {return def_epsilon;}
-    ///Set the default epsilon value.
+    ///Sets the default epsilon value.
     static void defaultEpsilon(Value e) {def_epsilon=e;}
 
     ///\name Comparisons
-    ///See class Tolerance for more details.
+    ///See \ref Tolerance for more details.
 
     ///@{
@@ -245,7 +241,7 @@
   };
 
-  ///Integer specialization of \ref Tolerance.
-
-  ///Integer specialization of \ref Tolerance.
+  ///Integer specialization of Tolerance.
+
+  ///Integer specialization of Tolerance.
   ///\sa Tolerance
   template<>
@@ -278,7 +274,7 @@
   };
 
+  ///Unsigned integer specialization of Tolerance.
+
   ///Unsigned integer specialization of \ref Tolerance.
-
-  ///Unsigned integer specialization of \ref Tolerance.
   ///\sa Tolerance
   template<>
@@ -312,7 +308,7 @@
   
 
-  ///Long integer specialization of \ref Tolerance.
-
-  ///Long integer specialization of \ref Tolerance.
+  ///Long integer specialization of Tolerance.
+
+  ///Long integer specialization of Tolerance.
   ///\sa Tolerance
   template<>
@@ -345,7 +341,7 @@
   };
 
+  ///Unsigned long integer specialization of Tolerance.
+
   ///Unsigned long integer specialization of \ref Tolerance.
-
-  ///Unsigned long integer specialization of \ref Tolerance.
   ///\sa Tolerance
   template<>
@@ -380,5 +376,5 @@
 #if defined __GNUC__ && !defined __STRICT_ANSI__
 
-  ///Long long integer specialization of \ref Tolerance.
+  ///Long long integer specialization of Tolerance.
 
   ///Long long integer specialization of \ref Tolerance.
@@ -415,5 +411,5 @@
   };
 
-  ///Unsigned long long integer specialization of \ref Tolerance.
+  ///Unsigned long long integer specialization of Tolerance.
 
   ///Unsigned long long integer specialization of \ref Tolerance.
