Changes in / [37:582c594ecd01:35:f8ddf1b1541a] in lemon-main

Files:

• .hgignore (modified) (2 diffs)
• INSTALL (deleted)
• LICENSE (deleted)
• Makefile.am (modified) (1 diff)
• NEWS (deleted)
• README (deleted)
• configure.ac (modified) (1 diff)
• lemon/Makefile.am (modified) (3 diffs)
• lemon/bits/invalid.h (modified) (2 diffs)
• lemon/dim2.h (deleted)
• lemon/maps.h (modified) (69 diffs)
• lemon/random.cc (deleted)
• lemon/random.h (deleted)
• lemon/tolerance.h (modified) (10 diffs)
• test/Makefile.am (modified) (1 diff)
• test/dim_test.cc (deleted)
• test/random_test.cc (deleted)

.hgignore

@@ -6 +6 @@
 *.o
 .#.*
-*.log
-*.lo
-*.tar.*
 Makefile.in
 aclocal.m4
@@ -23 +20 @@
 lemon/stamp-h2
 doc/Doxyfile
-.dirstamp
-.libs/*
-.deps/*
+lemon/.dirstamp
+lemon/.libs/*
 
 syntax: regexp
-^doc/html/.*
-^autom4te.cache/.*
-^build-aux/.*
-^objs.*/.*
-^test/[a-z_]*$
+html/.*
+autom4te.cache/.*
+build-aux/.*
+objs.*/.*

Makefile.am

@@ -5 +5 @@
 
 EXTRA_DIST = \
-        LICENSE \
         m4/lx_check_cplex.m4 \
         m4/lx_check_glpk.m4 \

configure.ac

@@ -7 +7 @@
 m4_define([lemon_version_nano], [])
 m4_define([lemon_version_tag], [hg])
-m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))])
-m4_define([lemon_version], [lemon_version_major().lemon_version_minor()ifelse(lemon_version_micro(), [], [], [.lemon_version_micro()])ifelse(lemon_version_nano(), [], [], [.lemon_version_nano()])ifelse(lemon_version_tag(), [], [], lemon_version_tag(), [hg], [[_]lemon_version_tag()[_]lemon_hg_revision()], [[_]lemon_version_tag()])])
+m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg tip |grep ^changeset |cut -d ':' -f 3]))])
+m4_define([lemon_version], [lemon_version_major().lemon_version_minor()ifelse(lemon_version_micro(), [], [], [.lemon_version_micro()])ifelse(lemon_version_nano(), [], [], [.lemon_version_nano()])ifelse(lemon_version_tag(), [], [], lemon_version_tag(), [hg], [[_]lemon_version_tag()[]lemon_hg_revision()], [[_]lemon_version_tag()])])
 
 AC_PREREQ([2.59])

lemon/Makefile.am

@@ -8 +8 @@
 
 lemon_libemon_la_SOURCES = \
-        lemon/base.cc \
-        lemon/random.cc
-
+        lemon/base.cc
 
 lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)
@@ -16 +14 @@
 
 lemon_HEADERS += \
-        lemon/dim2.h \
-        lemon/random.h \
+        lemon/concept_check.h \
         lemon/list_graph.h \
+        lemon/maps.h \
         lemon/tolerance.h
 
@@ -25 +23 @@
         lemon/bits/utility.h
 
-concept_HEADERS +=
+concept_HEADERS += \
+        lemon/concepts/maps.h

lemon/bits/invalid.h

@@ -25 +25 @@
 namespace lemon {
 
-  /// \brief Dummy type to make it easier to create invalid iterators.
+  /// \brief Dummy type to make it easier to make invalid iterators.
   ///
   /// See \ref INVALID for the usage.
@@ -35 +35 @@
   };
   
-  /// \brief Invalid iterators.
-  ///
+  /// Invalid iterators.
+  
   /// \ref Invalid is a global type that converts to each iterator
   /// in such a way that the value of the target iterator will be invalid.

lemon/maps.h

@@ -45 +45 @@
   class MapBase {
   public:
-    /// The key type of the map.
+    ///\e
     typedef K Key;
-    /// The value type of the map. (The type of objects associated with the keys).
+    ///\e
     typedef T Value;
   };
@@ -53 +53 @@
   /// Null map. (a.k.a. DoNothingMap)
 
-  /// This map can be used if you have to provide a map only for
-  /// its type definitions, or if you have to provide a writable map, 
-  /// but data written to it is not required (i.e. it will be sent to 
-  /// <tt>/dev/null</tt>).
+  /// If you have to provide a map only for its type definitions,
+  /// or if you have to provide a writable map, but
+  /// data written to it will sent to <tt>/dev/null</tt>...
   template<typename K, typename T>
   class NullMap : public MapBase<K, T> {
@@ -70 +69 @@
   };
 
-  ///Returns a \c NullMap class
-
-  ///This function just returns a \c NullMap class.
-  ///\relates NullMap
   template <typename K, typename V> 
   NullMap<K, V> nullMap() {
@@ -96 +91 @@
     /// Default constructor
 
-    /// Default constructor.
     /// The value of the map will be uninitialized. 
     /// (More exactly it will be default constructed.)
     ConstMap() {}
-    
-    /// Constructor with specified initial value
-
-    /// Constructor with specified initial value.
-    /// \param _v is the initial value of the map.
+    ///\e
+
+    /// \param _v The initial value of the map.
+    ///
     ConstMap(const T &_v) : v(_v) {}
     
@@ -166 +159 @@
   ///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().
+  ///This is essentially a wrapper for \c std::map. With addition that
+  ///you can specify a default value different from \c Value() .
   template <typename K, typename T, typename Compare = std::less<K> >
   class StdMap {
@@ -250 +243 @@
   };
 
-  /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
-  ///
-  /// The current map has the <tt>[0..size-1]</tt> keyset and the values
+  /// \brief Map for storing values for the range \c [0..size-1] range keys
+  ///
+  /// The current map has the \c [0..size-1] 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 
@@ -329 +322 @@
   /// @{
 
-  /// \brief Identity map.
-  ///
-  /// This map gives back the given key as value without any
+  /// \brief Identity mapping.
+  ///
+  /// This mapping gives back the given key as value without any
   /// modification. 
   template <typename T>
@@ -360 +353 @@
   ///
   ///This \c concepts::ReadMap "read only map"
-  ///converts the \c Value of a map to type \c T.
+  ///converts the \c Value of a maps to type \c T.
   ///Its \c Key is inherited from \c M.
   template <typename M, typename T> 
@@ -372 +365 @@
     ///Constructor
 
-    ///Constructor.
-    ///\param _m is the underlying map.
+    ///Constructor
+    ///\param _m is the underlying map
     ConvertMap(const M &_m) : m(_m) {};
 
@@ -382 +375 @@
   };
   
-  ///Returns a \c ConvertMap class
-
-  ///This function just returns a \c ConvertMap class.
+  ///Returns an \c ConvertMap class
+
+  ///This function just returns an \c ConvertMap class.
   ///\relates ConvertMap
   template<typename T, typename M>
@@ -391 +384 @@
   }
 
-  ///Simple wrapping of a map
+  ///Simple wrapping of the map
 
   ///This \c concepts::ReadMap "read only map" returns the simple
@@ -398 +391 @@
   ///map to simple read map.
   ///
-  ///\sa SimpleWriteMap
-  ///
-  /// \todo Revise the misleading name 
+  /// \todo Revise the misleading name
   template<typename M> 
   class SimpleMap : public MapBase<typename M::Key, typename M::Value> {
@@ -416 +407 @@
   };
 
-  ///Simple writable wrapping of the map
+  ///Simple writeable wrapping of the map
 
   ///This \c concepts::WriteMap "write map" returns the simple
@@ -423 +414 @@
   ///given map to simple read-write map.
   ///
-  ///\sa SimpleMap
-  ///
   /// \todo Revise the misleading name
   template<typename M> 
@@ -446 +435 @@
 
   ///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.
+  ///given maps. Its \c Key and \c Value will be inherited from \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> {
@@ -480 +469 @@
   ///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.
+  ///Its \c Key and \c Value is inherited from \c M.
   ///
   ///Actually,
@@ -486 +475 @@
   ///  ShiftMap<X> sh(x,v);
   ///\endcode
-  ///is equivalent to
+  ///is equivalent with
   ///\code
   ///  ConstMap<X::Key, X::Value> c_tmp(v);
   ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
   ///\endcode
-  ///
-  ///\sa ShiftWriteMap
   template<typename M, typename C = typename M::Value> 
   class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
@@ -504 +491 @@
     ///Constructor
 
-    ///Constructor.
-    ///\param _m is the undelying map.
-    ///\param _v is the shift value.
+    ///Constructor
+    ///\param _m is the undelying map
+    ///\param _v is the shift value
     ShiftMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
     ///\e
@@ -512 +499 @@
   };
 
-  ///Shift a map with a constant (ReadWrite version).
+  ///Shift a map with a constant. This map is also writable.
 
   ///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.
-  ///
-  ///\sa ShiftMap
+  ///Its \c Key and \c Value is inherited from \c M.
+  ///
+  ///Actually,
+  ///\code
+  ///  ShiftMap<X> sh(x,v);
+  ///\endcode
+  ///is equivalent with
+  ///\code
+  ///  ConstMap<X::Key, X::Value> c_tmp(v);
+  ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
+  ///\endcode
   template<typename M, typename C = typename M::Value> 
   class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
@@ -530 +525 @@
     ///Constructor
 
-    ///Constructor.
-    ///\param _m is the undelying map.
-    ///\param _v is the shift value.
+    ///Constructor
+    ///\param _m is the undelying map
+    ///\param _v is the shift value
     ShiftWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
     /// \e
@@ -540 +535 @@
   };
   
-  ///Returns a \c ShiftMap class
-
-  ///This function just returns a \c ShiftMap class.
+  ///Returns an \c ShiftMap class
+
+  ///This function just returns an \c ShiftMap class.
   ///\relates ShiftMap
   template<typename M, typename C> 
@@ -549 +544 @@
   }
 
-  ///Returns a \c ShiftWriteMap class
-
-  ///This function just returns a \c ShiftWriteMap class.
-  ///\relates ShiftWriteMap
   template<typename M, typename C> 
   inline ShiftWriteMap<M, C> shiftMap(M &m,const C &v) {
@@ -561 +552 @@
 
   ///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.
+  ///of the values of the two
+  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
   ///
@@ -594 +585 @@
 
   ///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.
+  ///values of the two
+  ///given
+  ///maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
+
   template<typename M1, typename M2> 
   class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -621 +614 @@
   }
  
-  ///Scales a map with a constant.
+  ///Scales a maps with a constant.
 
   ///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.
+  ///Its \c Key and \c Value is inherited from \c M.
   ///
   ///Actually,
@@ -631 +624 @@
   ///  ScaleMap<X> sc(x,v);
   ///\endcode
-  ///is equivalent to
+  ///is equivalent with
   ///\code
   ///  ConstMap<X::Key, X::Value> c_tmp(v);
   ///  MulMap<X, ConstMap<X::Key, X::Value> > sc(x,v);
   ///\endcode
-  ///
-  ///\sa ScaleWriteMap
   template<typename M, typename C = typename M::Value> 
   class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
@@ -649 +640 @@
     ///Constructor
 
-    ///Constructor.
-    ///\param _m is the undelying map.
-    ///\param _v is the scaling value.
+    ///Constructor
+    ///\param _m is the undelying map
+    ///\param _v is the scaling value
     ScaleMap(const M &_m, const C &_v ) : m(_m), v(_v) {};
     /// \e
@@ -657 +648 @@
   };
 
-  ///Scales a map with a constant (ReadWrite version).
+  ///Scales a maps with a constant (ReadWrite version).
 
   ///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
-  ///\c Value and \c C and the given multiplier is not zero.
-  ///Its \c Key and \c Value are inherited from \c M.
-  ///
-  ///\sa ScaleMap
+  ///be used as write map also if the given multiplier is not zero.
+  ///Its \c Key and \c Value is inherited from \c M.
   template<typename M, typename C = typename M::Value> 
   class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
@@ -677 +665 @@
     ///Constructor
 
-    ///Constructor.
-    ///\param _m is the undelying map.
-    ///\param _v is the scaling value.
+    ///Constructor
+    ///\param _m is the undelying map
+    ///\param _v is the scaling value
     ScaleWriteMap(M &_m, const C &_v ) : m(_m), v(_v) {};
     /// \e
@@ -687 +675 @@
   };
   
-  ///Returns a \c ScaleMap class
-
-  ///This function just returns a \c ScaleMap class.
+  ///Returns an \c ScaleMap class
+
+  ///This function just returns an \c ScaleMap class.
   ///\relates ScaleMap
   template<typename M, typename C> 
@@ -696 +684 @@
   }
 
-  ///Returns a \c ScaleWriteMap class
-
-  ///This function just returns a \c ScaleWriteMap class.
-  ///\relates ScaleWriteMap
   template<typename M, typename C> 
   inline ScaleWriteMap<M, C> scaleMap(M &m,const C &v) {
@@ -708 +692 @@
 
   ///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.
+  ///values of the two
+  ///given maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
+
   template<typename M1, typename M2> 
   class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -738 +723 @@
 
   ///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,
+  ///two
+  ///given maps. That is to say, if \c m1 is of type \c M1 and \c m2 is
+  ///of \c M2,
   ///then for
   ///\code
   ///  ComposeMap<M1, M2> cm(m1,m2);
   ///\endcode
-  /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>.
-  ///
-  ///Its \c Key is inherited from \c M2 and its \c Value is from \c M1.
-  ///\c M2::Value must be convertible to \c M1::Key.
-  ///
-  ///\sa CombineMap
-  ///
+  /// <tt>cm[x]</tt> will be equal to <tt>m1[m2[x]]</tt>
+  ///
+  ///Its \c Key is inherited from \c M2 and its \c Value is from
+  ///\c M1.
+  ///The \c M2::Value must be convertible to \c M1::Key.
   ///\todo Check the requirements.
   template <typename M1, typename M2> 
@@ -774 +758 @@
     operator[](Key k) const {return m1[m2[k]];}
   };
-
   ///Returns a \c ComposeMap class
 
   ///This function just returns a \c ComposeMap class.
+  ///
   ///\relates ComposeMap
   template <typename M1, typename M2> 
@@ -784 +768 @@
   }
   
-  ///Combine of two maps using an STL (binary) functor.
-
-  ///Combine of two maps using an STL (binary) functor.
+  ///Combines of two maps using an STL (binary) functor.
+
+  ///Combines of two maps using an STL (binary) functor.
+  ///
   ///
   ///This \c concepts::ReadMap "read only map" takes two maps and a
-  ///binary functor and returns the composition of the two
+  ///binary functor and returns the composition of
+  ///the two
   ///given maps unsing the functor. 
   ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
-  ///and \c f is of \c F, then for
+  ///and \c f is of \c F,
+  ///then for
   ///\code
-  ///  CombineMap<M1,M2,F,V> cm(m1,m2,f);
+  ///  CombineMap<M1, M2,F,V> cm(m1,m2,f);
   ///\endcode
   /// <tt>cm[x]</tt> will be equal to <tt>f(m1[x],m2[x])</tt>
   ///
   ///Its \c Key is inherited from \c M1 and its \c Value is \c V.
-  ///\c M2::Value and \c M1::Value must be convertible to the corresponding
+  ///The \c M2::Value and \c M1::Value must be convertible to the corresponding
   ///input parameter of \c F and the return type of \c F must be convertible
   ///to \c V.
-  ///
-  ///\sa ComposeMap
-  ///
   ///\todo Check the requirements.
   template<typename M1, typename M2, typename F,
@@ -830 +814 @@
   ///For example if \c m1 and \c m2 are both \c double valued maps, then 
   ///\code
-  ///combineMap(m1,m2,std::plus<double>())
+  ///combineMap<double>(m1,m2,std::plus<double>())
   ///\endcode
-  ///is equivalent to
+  ///is equivalent with
   ///\code
   ///addMap(m1,m2)
@@ -838 +822 @@
   ///
   ///This function is specialized for adaptable binary function
-  ///classes and C++ functions.
+  ///classes and c++ functions.
   ///
   ///\relates CombineMap
@@ -862 +846 @@
 
   ///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.
+  ///value of the
+  ///value returned by the
+  ///given map. Its \c Key and \c Value will be inherited from \c M.
   ///The unary \c - operator must be defined for \c Value, of course.
-  ///
-  ///\sa NegWriteMap
+
   template<typename M> 
   class NegMap : public MapBase<typename M::Key, typename M::Value> {
@@ -884 +868 @@
 
   ///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.
+  ///value of the value returned by the
+  ///given map. Its \c Key and \c Value will be inherited from \c M.
   ///The unary \c - operator must be defined for \c Value, of course.
-  ///
-  /// \sa NegMap
+
   template<typename M> 
   class NegWriteMap : public MapBase<typename M::Key, typename M::Value> {
@@ -914 +897 @@
   }
 
-  ///Returns a \c NegWriteMap class
-
-  ///This function just returns a \c NegWriteMap class.
-  ///\relates NegWriteMap
   template <typename M> 
   inline NegWriteMap<M> negMap(M &m) {
@@ -926 +905 @@
 
   ///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. 
-  ///\c Value must be comparable to \c 0 and the unary \c -
+  ///of the
+  ///value returned by the
+  ///given map. Its \c Key and \c Value will be inherited
+  ///from <tt>M</tt>. <tt>Value</tt>
+  ///must be comparable to <tt>0</tt> and the unary <tt>-</tt>
   ///operator must be defined for it, of course.
+  ///
+
   template<typename M> 
   class AbsMap : public MapBase<typename M::Key, typename M::Value> {
@@ -948 +931 @@
   };
   
-  ///Returns an \c AbsMap class
-
-  ///This function just returns an \c AbsMap class.
+  ///Returns a \c AbsMap class
+
+  ///This function just returns a \c AbsMap class.
   ///\relates AbsMap
   template<typename M> 
@@ -960 +943 @@
 
   ///This \c concepts::ReadMap "read only map" returns the value
-  ///of a given functor.
+  ///of a
+  ///given map.
   ///
   ///Template parameters \c K and \c V will become its
-  ///\c Key and \c Value. 
-  ///In most cases they have to be given explicitly because a 
-  ///functor typically does not provide such typedefs.
+  ///\c Key and \c Value. They must be given explicitely
+  ///because a functor does not provide such typedefs.
   ///
   ///Parameter \c F is the type of the used functor.
-  ///
-  ///\sa MapFunctor
   template<typename F, 
            typename K = typename F::argument_type, 
@@ -991 +972 @@
   ///
   ///It is specialized for adaptable function classes and
-  ///C++ functions.
+  ///c++ functions.
   ///\relates FunctorMap
   template<typename K, typename V, typename F> inline 
@@ -1019 +1000 @@
   ///a ususal \c concepts::ReadMap "readable map",
   ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
-  ///
-  ///\sa FunctorMap
   template <typename M> 
   class MapFunctor : public MapBase<typename M::Key, typename M::Value> {
@@ -1055 +1034 @@
   ///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 will be inherited from \c M1.
   ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
-  ///
-  ///\sa ForkWriteMap
   ///
   /// \todo Why is it needed?
@@ -1085 +1062 @@
   ///corresponding values of \c M1.
   ///
-  ///The \c Key and \c Value are inherited from \c M1.
+  ///The \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
-  ///
-  ///\sa ForkMap
   template<typename  M1, typename M2> 
   class ForkWriteMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -1106 +1081 @@
   };
   
-  ///Returns a \c ForkMap class
-
-  ///This function just returns a \c ForkMap class.
+  ///Returns an \c ForkMap class
+
+  ///This function just returns an \c ForkMap class.
+  ///
   ///\relates ForkMap
   template <typename M1, typename M2> 
@@ -1115 +1091 @@
   }
 
-  ///Returns a \c ForkWriteMap class
-
-  ///This function just returns a \c ForkWriteMap class.
-  ///\relates ForkWriteMap
   template <typename M1, typename M2> 
   inline ForkWriteMap<M1, M2> forkMap(M1 &m1, M2 &m2) {
@@ -1131 +1103 @@
   
   ///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 Value is \c bool.
-  ///
-  ///\sa NotWriteMap
+  ///logical negation of
+  ///value returned by the
+  ///given map. Its \c Key and will be inherited from \c M,
+  ///its Value is <tt>bool</tt>.
   template <typename M> 
   class NotMap : public MapBase<typename M::Key, bool> {
@@ -1152 +1124 @@
   
   ///This bool \c concepts::ReadWriteMap "read-write map" returns the 
-  ///logical negation of the value returned by the given map. When it is set,
+  ///logical negation of 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 Value is \c bool.
-  ///
-  ///\sa NotMap
+  ///Its \c Key and will be inherited from \c M,
+  ///its Value is <tt>bool</tt>.
   template <typename M> 
   class NotWriteMap : public MapBase<typename M::Key, bool> {
@@ -1182 +1153 @@
   }
   
-  ///Returns a \c NotWriteMap class
-  
-  ///This function just returns a \c NotWriteMap class.
-  ///\relates NotWriteMap
   template <typename M> 
   inline NotWriteMap<M> notMap(M &m) {
@@ -1217 +1184 @@
   
 
-  /// \brief Writable bool map for logging each \c true assigned element
-  ///
-  /// 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.
+  /// \brief Writable bool map for logging each true assigned elements
+  ///
+  /// Writable bool map for logging each true assigned elements, i.e it
+  /// copies all the keys set to true to the given iterator.
   ///
   /// \note The container of the iterator should contain space 
@@ -1241 +1208 @@
   ///\endcode
   ///
-  ///\sa BackInserterBoolMap 
-  ///\sa FrontInserterBoolMap 
-  ///\sa InserterBoolMap 
-  ///
-  ///\todo Revise the name of this class and the related ones.
+  ///\todo Revise the name of this class and the relates ones.
   template <typename _Iterator, 
             typename _Functor =
@@ -1273 +1236 @@
     }
 
-    /// The \c set function of the map
+    /// Setter function of the map
     void set(const Key& key, Value value) const {
       if (value) {
@@ -1286 +1249 @@
   };
 
-  /// \brief Writable bool map for logging each \c true assigned element in 
-  /// a back insertable container.
-  ///
-  /// Writable bool map for logging each \c true assigned element by pushing
-  /// them into a back insertable container.
+  /// \brief Writable bool map for logging each true assigned elements in 
+  /// a back insertable container
+  ///
+  /// Writable bool map for logging each true assigned elements by pushing
+  /// back them into a back insertable container.
   /// It can be used to retrieve the items into a standard
   /// container. The next example shows how you can store the
@@ -1300 +1263 @@
   /// prim(graph, cost, inserter_map);
   ///\endcode
-  ///
-  ///\sa StoreBoolMap
-  ///\sa FrontInserterBoolMap
-  ///\sa InserterBoolMap
   template <typename Container,
             typename Functor =
@@ -1309 +1268 @@
   class BackInserterBoolMap {
   public:
-    typedef typename Functor::argument_type Key;
+    typedef typename Container::value_type Key;
     typedef bool Value;
 
@@ -1317 +1276 @@
       : container(_container), functor(_functor) {}
 
-    /// The \c set function of the map
+    /// Setter function of the map
     void set(const Key& key, Value value) {
       if (value) {
@@ -1329 +1288 @@
   };
 
-  /// \brief Writable bool map for logging each \c true assigned element in 
+  /// \brief Writable bool map for storing each true assignments in 
   /// a front insertable container.
   ///
-  /// Writable bool map for logging each \c true assigned element by pushing
-  /// them into a front insertable container.
-  /// It can be used to retrieve the items into a standard
-  /// container. For example see \ref BackInserterBoolMap.
-  ///
-  ///\sa BackInserterBoolMap
-  ///\sa InserterBoolMap
+  /// Writable bool map for storing each true assignment in a front 
+  /// insertable container. It will push front all the keys set to \c true into
+  /// the container. For example see the BackInserterBoolMap.
   template <typename Container,
             typename Functor =
@@ -1344 +1299 @@
   class FrontInserterBoolMap {
   public:
-    typedef typename Functor::argument_type Key;
+    typedef typename Container::value_type Key;
     typedef bool Value;
 
@@ -1352 +1307 @@
       : container(_container), functor(_functor) {}
 
-    /// The \c set function of the map
+    /// Setter function of the map
     void set(const Key& key, Value value) {
       if (value) {
-        container.push_front(functor(key));
+        container.push_front(key);
       }
     }
@@ -1364 +1319 @@
   };
 
-  /// \brief Writable bool map for storing each \c true assigned element in 
+  /// \brief Writable bool map for storing each true assigned elements in 
   /// an insertable container.
   ///
-  /// Writable bool map for storing each \c true assigned element in an 
+  /// Writable bool map for storing each true assigned elements in an 
   /// insertable container. It will insert all the keys set to \c true into
   /// the container.
@@ -1379 +1334 @@
   /// stronglyConnectedCutArcs(digraph, cost, inserter_map);
   ///\endcode
-  ///
-  ///\sa BackInserterBoolMap
-  ///\sa FrontInserterBoolMap
   template <typename Container,
             typename Functor =
@@ -1390 +1342 @@
     typedef bool Value;
 
-    /// Constructor with specified iterator
-    
-    /// Constructor with specified iterator.
-    /// \param _container The container for storing the elements.
-    /// \param _it The elements will be inserted before this iterator.
-    /// \param _functor The functor that is used when an element is stored.
+    /// Constructor
     InserterBoolMap(Container& _container, typename Container::iterator _it,
                     const Functor& _functor = Functor()) 
@@ -1401 +1348 @@
 
     /// Constructor
-
-    /// Constructor without specified iterator.
-    /// The elements will be inserted before <tt>_container.end()</tt>.
-    /// \param _container The container for storing the elements.
-    /// \param _functor The functor that is used when an element is stored.
     InserterBoolMap(Container& _container, const Functor& _functor = Functor())
       : container(_container), it(_container.end()), functor(_functor) {}
 
-    /// The \c set function of the map
+    /// Setter function of the map
     void set(const Key& key, Value value) {
       if (value) {
-        it = container.insert(it, functor(key));
+        it = container.insert(it, key);
         ++it;
       }
@@ -1423 +1365 @@
   };
 
-  /// \brief Writable bool map for filling each \c true assigned element with a 
-  /// given value.
-  ///
-  /// Writable bool map for filling each \c true assigned element with a 
-  /// given value. The value can set the container.
+  /// \brief Fill the true set elements with a given value.
+  ///
+  /// Writable bool map to fill the elements set to \c true with a given value.
+  /// The value can set 
+  /// the container.
   ///
   /// The following code finds the connected components of a graph
@@ -1477 +1419 @@
     } 
 
-    /// The \c set function of the map
+    /// Set function of the map
     void set(const Key& key, Value value) {
       if (value) {
@@ -1490 +1432 @@
 
 
-  /// \brief Writable bool map for storing the sequence number of 
-  /// \c true assignments.  
+  /// \brief Writable bool map which stores the sequence number of 
+  /// true assignments.  
   /// 
-  /// Writable bool map that stores for each \c true assigned elements  
+  /// Writable bool map which stores for each true assigned elements  
   /// the sequence number of this setting.
   /// It makes it easy to calculate the leaving

lemon/tolerance.h

@@ -49 +49 @@
   ///\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>
@@ -135 +131 @@
     bool negative(Value a) const { return -_epsilon>a; }
     ///Returns \c true if \c a is \e surely non-zero
-    bool nonZero(Value a) const { return positive(a)||negative(a); }
+    bool nonZero(Value a) const { return positive(a)||negative(a); };
 
     ///@}
@@ -186 +182 @@
     bool negative(Value a) const { return -_epsilon>a; }
     ///Returns \c true if \c a is \e surely non-zero
-    bool nonZero(Value a) const { return positive(a)||negative(a); }
+    bool nonZero(Value a) const { return positive(a)||negative(a); };
 
     ///@}
@@ -237 +233 @@
     bool negative(Value a) const { return -_epsilon>a; }
     ///Returns \c true if \c a is \e surely non-zero
-    bool nonZero(Value a) const { return positive(a)||negative(a); }
+    bool nonZero(Value a) const { return positive(a)||negative(a); };
 
     ///@}
@@ -270 +266 @@
     static bool negative(Value a) { return 0>a; }
     ///Returns \c true if \c a is \e surely non-zero
-    static bool nonZero(Value a) { return a!=0; }
+    static bool nonZero(Value a) { return a!=0; };
 
     ///@}
@@ -303 +299 @@
     static bool negative(Value) { return false; }
     ///Returns \c true if \c a is \e surely non-zero
-    static bool nonZero(Value a) { return a!=0; }
+    static bool nonZero(Value a) { return a!=0; };
 
     ///@}
@@ -337 +333 @@
     static bool negative(Value a) { return 0>a; }
     ///Returns \c true if \c a is \e surely non-zero
-    static bool nonZero(Value a) { return a!=0;}
+    static bool nonZero(Value a) { return a!=0;};
 
     ///@}
@@ -370 +366 @@
     static bool negative(Value) { return false; }
     ///Returns \c true if \c a is \e surely non-zero
-    static bool nonZero(Value a) { return a!=0;}
+    static bool nonZero(Value a) { return a!=0;};
 
     ///@}
@@ -407 +403 @@
     static bool negative(Value a) { return 0>a; }
     ///Returns \c true if \c a is \e surely non-zero
-    static bool nonZero(Value a) { return a!=0;}
+    static bool nonZero(Value a) { return a!=0;};
 
     ///@}
@@ -442 +438 @@
     static bool negative(Value) { return false; }
     ///Returns \c true if \c a is \e surely non-zero
-    static bool nonZero(Value a) { return a!=0;}
+    static bool nonZero(Value a) { return a!=0;};
 
     ///@}

test/Makefile.am

@@ -4 +4 @@
 noinst_HEADERS += \
         test/test_tools.h
-
+ 
 check_PROGRAMS += \
-        test/dim_test \
-        test/random_test \
+        test/maps_test \
         test/test_tools_fail \
         test/test_tools_pass
-
+ 
 TESTS += $(check_PROGRAMS)
 XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
 
-test_dim_test_SOURCES = test/dim_test.cc
-test_random_test_SOURCES = test/random_test.cc
+test_maps_test_SOURCES = test/maps_test.cc
 test_test_tools_fail_SOURCES = test/test_tools_fail.cc
 test_test_tools_pass_SOURCES = test/test_tools_pass.cc