Diff [5100072d83caa82eaf0be1a84a27e5d1917f2efd:d2bc45e8f6f23e94ddf7cef395c4c169529d1da8] for / – LEMON

CMakeLists.txt

r727	r791
35	35	CHECK_TYPE_SIZE("long long" LONG_LONG)
36	36	SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
	37
	38	INCLUDE(FindPythonInterp)
37	39
38	40	ENABLE_TESTING()

INSTALL

-                      r615
+                      r890
    Disable COIN-OR support.
+Makefile Variables
+==================
+Some Makefile variables are reserved by the GNU Coding Standards for
+the use of the "user" - the person building the package. For instance,
+CXX and CXXFLAGS are such variables, and have the same meaning as
+explained in the previous section. These variables can be set on the
+command line when invoking `make' like this:
+`make [VARIABLE=VALUE]...'
+WARNINGCXXFLAGS is a non-standard Makefile variable introduced by us
+to hold several compiler flags related to warnings. Its default value
+can be overridden when invoking `make'. For example to disable all
+warning flags use `make WARNINGCXXFLAGS='.
+In order to turn off a single flag from the default set of warning
+flags, you can use the CXXFLAGS variable, since this is passed after
+WARNINGCXXFLAGS. For example to turn off `-Wold-style-cast' (which is
+used by default when g++ is detected) you can use
+`make CXXFLAGS="-g -O2 -Wno-old-style-cast"'.

Makefile.am

-                      r676
+                      r840
         cmake/FindGLPK.cmake \
         cmake/FindCOIN.cmake \
+        cmake/LEMONConfig.cmake.in \
         cmake/version.cmake.in \
         cmake/version.cmake \
 …
 include doc/Makefile.am
 include tools/Makefile.am
+include scripts/Makefile.am
 DIST_SUBDIRS = demo

configure.ac

-                      r727
+                      r840
 AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
+AC_CHECK_PROG([python_found],[python],[yes],[no])
 AC_CHECK_PROG([gs_found],[gs],[yes],[no])
 …
 fi
 AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
+dnl Support for running test cases using valgrind.
+use_valgrind=no
+AC_ARG_ENABLE([valgrind],
+AS_HELP_STRING([--enable-valgrind], [use valgrind when running tests]),
+              [use_valgrind=yes])
+if [[ "$use_valgrind" = "yes" ]]; then
+  AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
+  if [[ "$HAVE_VALGRIND" = "no" ]]; then
+    AC_MSG_ERROR([Valgrind not found in PATH.])
+  fi
+fi
+AM_CONDITIONAL(USE_VALGRIND, [test "$use_valgrind" = "yes"])
 dnl Checks for header files.
 …
 echo
 echo Build additional tools........ : $enable_tools
+echo Use valgrind for tests........ : $use_valgrind
 echo
 echo The packace will be installed in

doc/CMakeLists.txt

-                      r726
+                      r895
+)
 IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
+IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
   FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
   SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha)
 …
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
+    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/planar.png ${CMAKE_CURRENT_SOURCE_DIR}/images/planar.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
     COMMAND ${CMAKE_COMMAND} -E remove_directory html
+    COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
     COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

doc/Doxyfile.in

-                      r379
+                      r803
 # Doxyfile 1.5.7.1
+# Doxyfile 1.5.9
 #---------------------------------------------------------------------------
 …
 QT_AUTOBRIEF           = NO
 MULTILINE_CPP_IS_BRIEF = NO
-DETAILS_AT_TOP         = YES
 INHERIT_DOCS           = NO
 SEPARATE_MEMBER_PAGES  = NO
 …
                          "@abs_top_srcdir@/demo" \
                          "@abs_top_srcdir@/tools" \
+                         "@abs_top_srcdir@/test/test_tools.h"
+                         "@abs_top_srcdir@/test/test_tools.h" \
+                         "@abs_top_builddir@/doc/references.dox"
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
 …
 SKIP_FUNCTION_MACROS   = YES
 #---------------------------------------------------------------------------
 # Configuration::additions related to external references
+# Options related to the search engine
 #---------------------------------------------------------------------------
 TAGFILES               = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "

doc/Makefile.am

-                      r720
+                      r895
         edge_biconnected_components.eps \
         node_biconnected_components.eps \
+        planar.eps \
         strongly_connected_components.eps
 …
         fi
+html-local: $(DOC_PNG_IMAGES)
+references.dox: doc/references.bib
+        if test ${python_found} = yes; then \
+          cd doc; \
+          python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \
+          cd ..; \
+        else \
+          echo; \
+          echo "Python not found."; \
+          echo; \
+          exit 1; \
+        fi
+html-local: $(DOC_PNG_IMAGES) references.dox
         if test ${doxygen_found} = yes; then \
           cd doc; \

doc/groups.dox

-                      r710
+                      r879
 /**
-@defgroup matrices Matrices
-@ingroup datas
-\brief Two dimensional data storages implemented in LEMON.
-This group contains two dimensional data storages implemented in LEMON.
-*/
-/**
 @defgroup paths Path Structures
 @ingroup datas
 …
 any kind of path structure.
+\sa lemon::concepts::Path
+\sa \ref concepts::Path "Path concept"
+*/
+/**
+@defgroup heaps Heap Structures
+@ingroup datas
+\brief %Heap structures implemented in LEMON.
+This group contains the heap structures implemented in LEMON.
+LEMON provides several heap classes. They are efficient implementations
+of the abstract data type \e priority \e queue. They store items with
+specified values called \e priorities in such a way that finding and
+removing the item with minimum priority are efficient.
+The basic operations are adding and erasing items, changing the priority
+of an item, etc.
+Heaps are crucial in several algorithms, such as Dijkstra and Prim.
+The heap implementations have the same interface, thus any of them can be
+used easily in such algorithms.
+\sa \ref concepts::Heap "Heap concept"
+*/
+/**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+This group contains two dimensional data storages implemented in LEMON.
 */
 …
 /**
+@defgroup geomdat Geometric Data Structures
+@ingroup auxdat
+\brief Geometric data structures implemented in LEMON.
+This group contains geometric data structures implemented in LEMON.
+ - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional
+   vector with the usual operations.
+ - \ref lemon::dim2::Box "dim2::Box" can be used to determine the
+   rectangular bounding box of a set of \ref lemon::dim2::Point
+   "dim2::Point"'s.
+*/
+/**
+@defgroup matrices Matrices
+@ingroup auxdat
+\brief Two dimensional data storages implemented in LEMON.
+This group contains two dimensional data storages implemented in LEMON.
+*/
+/**
 @defgroup algs Algorithms
 \brief This group contains the several algorithms
 …
 This group contains the common graph search algorithms, namely
+\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
+\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
+\ref clrs01algorithms.
 */
 …
 \brief Algorithms for finding shortest paths.
+This group contains the algorithms for finding shortest paths in digraphs.
+This group contains the algorithms for finding shortest paths in digraphs
+\ref clrs01algorithms.
  - \ref Dijkstra algorithm for finding shortest paths from a source node
 …
 /**
+@defgroup spantree Minimum Spanning Tree Algorithms
+@ingroup algs
+\brief Algorithms for finding minimum cost spanning trees and arborescences.
+This group contains the algorithms for finding minimum cost spanning
+trees and arborescences \ref clrs01algorithms.
+*/
+/**
 @defgroup max_flow Maximum Flow Algorithms
 @ingroup algs
 …
 This group contains the algorithms for finding maximum flows and
 feasible circulations.
+feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
 The \e maximum \e flow \e problem is to find a flow of maximum value between
 …
 LEMON contains several algorithms for solving maximum flow problems:
+- \ref EdmondsKarp Edmonds-Karp algorithm.
+- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.
+- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.
+- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.
+In most cases the \ref Preflow "Preflow" algorithm provides the
+- \ref EdmondsKarp Edmonds-Karp algorithm
+  \ref edmondskarp72theoretical.
+- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
+  \ref goldberg88newapproach.
+- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
+  \ref dinic70algorithm, \ref sleator83dynamic.
+- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
+  \ref goldberg88newapproach, \ref sleator83dynamic.
+In most cases the \ref Preflow algorithm provides the
 fastest method for computing a maximum flow. All implementations
 also provide functions to query the minimum cut, which is the dual
 …
 This group contains the algorithms for finding minimum cost flows and
+circulations. For more information about this problem and its dual
+solution see \ref min_cost_flow "Minimum Cost Flow Problem".
+circulations \ref amo93networkflows. For more information about this
+problem and its dual solution, see \ref min_cost_flow
+"Minimum Cost Flow Problem".
 LEMON contains several algorithms for this problem.
  - \ref NetworkSimplex Primal Network Simplex algorithm with various
+   pivot strategies.
+ - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
+   cost scaling.
+ - \ref CapacityScaling Successive Shortest %Path algorithm with optional
+   capacity scaling.
+ - \ref CancelAndTighten The Cancel and Tighten algorithm.
+ - \ref CycleCanceling Cycle-Canceling algorithms.
+   pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
+ - \ref CostScaling Cost Scaling algorithm based on push/augment and
+   relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
+   \ref bunnagel98efficient.
+ - \ref CapacityScaling Capacity Scaling algorithm based on the successive
+   shortest path method \ref edmondskarp72theoretical.
+ - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
+   strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
 In general NetworkSimplex is the most efficient implementation,
 …
 \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
     \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
+    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
 LEMON contains several algorithms related to minimum cut problems:
 …
 /**
+@defgroup graph_properties Connectivity and Other Graph Properties
+@ingroup algs
+\brief Algorithms for discovering the graph properties
+This group contains the algorithms for discovering the graph properties
+like connectivity, bipartiteness, euler property, simplicity etc.
+\image html edge_biconnected_components.png
+\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
+*/
+/**
+@defgroup planar Planarity Embedding and Drawing
+@ingroup algs
+\brief Algorithms for planarity checking, embedding and drawing
+This group contains the algorithms for planarity checking,
+embedding and drawing.
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
+@defgroup min_mean_cycle Minimum Mean Cycle Algorithms
+@ingroup algs
+\brief Algorithms for finding minimum mean cycles.
+This group contains the algorithms for finding minimum mean cycles
+\ref clrs01algorithms, \ref amo93networkflows.
+The \e minimum \e mean \e cycle \e problem is to find a directed cycle
+of minimum mean length (cost) in a digraph.
+The mean length of a cycle is the average length of its arcs, i.e. the
+ratio between the total length of the cycle and the number of arcs on it.
+This problem has an important connection to \e conservative \e length
+\e functions, too. A length function on the arcs of a digraph is called
+conservative if and only if there is no directed cycle of negative total
+length. For an arbitrary length function, the negative of the minimum
+cycle mean is the smallest \f$\epsilon\f$ value so that increasing the
+arc lengths uniformly by \f$\epsilon\f$ results in a conservative length
+function.
+LEMON contains three algorithms for solving the minimum mean cycle problem:
+- \ref Karp "Karp"'s original algorithm \ref amo93networkflows,
+  \ref dasdan98minmeancycle.
+- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved
+  version of Karp's algorithm \ref dasdan98minmeancycle.
+- \ref Howard "Howard"'s policy iteration algorithm
+  \ref dasdan98minmeancycle.
+In practice, the Howard algorithm proved to be by far the most efficient
+one, though the best known theoretical bound on its running time is
+exponential.
+Both Karp and HartmannOrlin algorithms run in time O(ne) and use space
+O(n<sup>2</sup>+e), but the latter one is typically faster due to the
+applied early termination scheme.
 */
 …
 /**
+@defgroup spantree Minimum Spanning Tree Algorithms
+@ingroup algs
+\brief Algorithms for finding minimum cost spanning trees and arborescences.
+This group contains the algorithms for finding minimum cost spanning
+trees and arborescences.
+@defgroup graph_properties Connectivity and Other Graph Properties
+@ingroup algs
+\brief Algorithms for discovering the graph properties
+This group contains the algorithms for discovering the graph properties
+like connectivity, bipartiteness, euler property, simplicity etc.
+\image html connected_components.png
+\image latex connected_components.eps "Connected components" width=\textwidth
+*/
+/**
+@defgroup planar Planarity Embedding and Drawing
+@ingroup algs
+\brief Algorithms for planarity checking, embedding and drawing
+This group contains the algorithms for planarity checking,
+embedding and drawing.
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
+*/
+/**
+@defgroup approx Approximation Algorithms
+@ingroup algs
+\brief Approximation algorithms.
+This group contains the approximation and heuristic algorithms
+implemented in LEMON.
 */
 …
 This group contains some algorithms implemented in LEMON
 in order to make it easier to implement complex algorithms.
-*/
-/**
-@defgroup approx Approximation Algorithms
-@ingroup algs
-\brief Approximation algorithms.
-This group contains the approximation and heuristic algorithms
-implemented in LEMON.
 */
 …
 /**
 @defgroup lp_group Lp and Mip Solvers
+@defgroup lp_group LP and MIP Solvers
 @ingroup gen_opt_group
+\brief Lp and Mip solver interfaces for LEMON.
+This group contains Lp and Mip solver interfaces for LEMON. The
+various LP solvers could be used in the same manner with this
+interface.
+\brief LP and MIP solver interfaces for LEMON.
+This group contains LP and MIP solver interfaces for LEMON.
+Various LP solvers could be used in the same manner with this
+high-level interface.
+The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
+\ref cplex, \ref soplex.
 */
 …
 /**
 @defgroup dimacs_group DIMACS format
+@defgroup dimacs_group DIMACS Format
 @ingroup io_group
 \brief Read and write files in DIMACS format
 …
 \brief Skeleton and concept checking classes for graph structures
 This group contains the skeletons and concept checking classes of LEMON's
 graph structures and helper classes used to implement these.
+This group contains the skeletons and concept checking classes of
+graph structures.
 */
 …
 /**
+@defgroup tools Standalone Utility Applications
+Some utility applications are listed here.
+The standard compilation procedure (<tt>./configure;make</tt>) will compile
+them, as well.
+*/
+/**
 \anchor demoprograms
 …
 */
-/**
-@defgroup tools Standalone Utility Applications
-Some utility applications are listed here.
-The standard compilation procedure (<tt>./configure;make</tt>) will compile
-them, as well.
-*/
+}

doc/mainpage.dox

-                      r705
+                      r802
 \section intro Introduction
+\subsection whatis What is LEMON
+LEMON stands for <b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
+and <b>O</b>ptimization in <b>N</b>etworks.
+It is a C++ template
+library aimed at combinatorial optimization tasks which
+often involve in working
+with graphs.
+<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
+and <b>O</b>ptimization in <b>N</b>etworks</i>.
+It is a C++ template library providing efficient implementation of common
+data structures and algorithms with focus on combinatorial optimization
+problems in graphs and networks.
 <b>
 …
 </b>
+\subsection howtoread How to read the documentation
+The project is maintained by the
+<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
+Combinatorial Optimization</a> \ref egres
+at the Operations Research Department of the
+<a href="http://www.elte.hu/">E&ouml;tv&ouml;s Lor&aacute;nd University,
+Budapest</a>, Hungary.
+LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
+initiative \ref coinor.
+\section howtoread How to Read the Documentation
 If you would like to get to know the library, see

doc/min_cost_flow.dox

-                      r710
+                      r835
 minimum total cost from a set of supply nodes to a set of demand nodes
 in a network with capacity constraints (lower and upper bounds)
 and arc costs.
+and arc costs \ref amo93networkflows.
 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
 …
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
    - \f$\pi(u)<=0\f$;
+   - \f$\pi(u)\leq 0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
 …
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
    - \f$\pi(u)>=0\f$;
+   - \f$\pi(u)\geq 0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.

lemon/Makefile.am

-                      r728
+                      r888
         lemon/arg_parser.h \
         lemon/assert.h \
+        lemon/bellman_ford.h \
         lemon/bfs.h \
         lemon/bin_heap.h \
+        lemon/binom_heap.h \
         lemon/bucket_heap.h \
+        lemon/capacity_scaling.h \
         lemon/cbc.h \
         lemon/circulation.h \
 …
         lemon/concept_check.h \
         lemon/connectivity.h \
+        lemon/core.h \
+        lemon/cost_scaling.h \
         lemon/counter.h \
-        lemon/core.h \
         lemon/cplex.h \
+        lemon/cycle_canceling.h \
         lemon/dfs.h \
         lemon/dijkstra.h \
 …
         lemon/euler.h \
         lemon/fib_heap.h \
+        lemon/fourary_heap.h \
         lemon/full_graph.h \
         lemon/glpk.h \
 …
         lemon/graph_to_eps.h \
         lemon/grid_graph.h \
+        lemon/hartmann_orlin.h \
+        lemon/howard.h \
         lemon/hypercube_graph.h \
+        lemon/karp.h \
+        lemon/kary_heap.h \
         lemon/kruskal.h \
         lemon/hao_orlin.h \
 …
         lemon/lp_base.h \
         lemon/lp_skeleton.h \
-        lemon/list_graph.h \
         lemon/maps.h \
         lemon/matching.h \
 …
         lemon/nauty_reader.h \
         lemon/network_simplex.h \
+        lemon/pairing_heap.h \
         lemon/path.h \
+        lemon/planarity.h \
         lemon/preflow.h \
         lemon/radix_heap.h \
 …
         lemon/smart_graph.h \
         lemon/soplex.h \
+        lemon/static_graph.h \
         lemon/suurballe.h \
         lemon/time_measure.h \

lemon/adaptors.h

-                      r703
+                      r834
   /// parameter is set to be \c const.
   ///
+  /// This class provides item counting in the same time as the adapted
+  /// digraph structure.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 …
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
 …
   /// parameter is set to be \c const.
   ///
+  /// This class provides only linear time counting for nodes, edges and arcs.
+  ///
   /// \tparam GR The type of the adapted graph.
   /// It must conform to the \ref concepts::Graph "Graph" concept.
 …
   /// by adding or removing nodes or arcs/edges, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides only linear time item counting.
   ///
   /// \tparam GR The type of the adapted digraph or graph.
 …
   /// parameter is set to be \c const.
   ///
+  /// This class provides only linear time counting for nodes and arcs.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 …
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides only linear time counting for nodes, edges and arcs.
   ///
   /// \tparam GR The type of the adapted graph.
 …
   /// parameter is set to be \c const.
   ///
+  /// This class provides item counting in the same time as the adapted
+  /// digraph structure.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 …
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides item counting in the same time as the adapted
+  /// graph structure.
   ///
   /// \tparam GR The type of the adapted graph.
 …
   /// arcs).
   /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
+  ///
+  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
 …
   /// in the adaptor.
   ///
+  /// This class provides item counting in the same time as the adapted
+  /// digraph structure.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.

lemon/bfs.h

-                      r525
+                      r891
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
 …
     ///The type of the map that indicates which nodes are processed.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
 …
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
+  ///\tparam TR The traits class that defines various types used by the
+  ///algorithm. By default, it is \ref BfsDefaultTraits
+  ///"BfsDefaultTraits<GR>".
+  ///In most cases, this parameter should not be set directly,
+  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
 …
     ///The simplest way to execute the BFS algorithm is to use one of the
     ///member functions called \ref run(Node) "run()".\n
     ///If you need more control on the execution, first you have to call
     ///\ref init(), then you can add several source nodes with
+    ///If you need better control on the execution, you have to call
+    ///\ref init() first, then you can add several source nodes with
     ///\ref addSource(). Finally the actual path computation can be
     ///performed with one of the \ref start() functions.
 …
     ///Runs the algorithm to visit all nodes in the digraph.
+    ///This method runs the %BFS algorithm in order to
+    ///compute the shortest path to each node.
+    ///
+    ///The algorithm computes
+    ///- the shortest path tree (forest),
+    ///- the distance of each node from the root(s).
+    ///This method runs the %BFS algorithm in order to visit all nodes
+    ///in the digraph.
     ///
     ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
 …
     ///@{
     ///The shortest path to a node.
     ///Returns the shortest path to a node.
+    ///The shortest path to the given node.
+    ///Returns the shortest path to the given node from the root(s).
     ///
     ///\warning \c t should be reached from the root(s).
 …
     Path path(Node t) const { return Path(*G, *_pred, t); }
     ///The distance of a node from the root(s).
     ///Returns the distance of a node from the root(s).
+    ///The distance of the given node from the root(s).
+    ///Returns the distance of the given node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
 …
     int dist(Node v) const { return (*_dist)[v]; }
+    ///Returns the 'previous arc' of the shortest path tree for a node.
+    ///\brief Returns the 'previous arc' of the shortest path tree for
+    ///the given node.
+    ///
     ///This function returns the 'previous arc' of the shortest path
     ///tree for the node \c v, i.e. it returns the last arc of a
 …
     ///
     ///The shortest path tree used here is equal to the shortest path
     ///tree used in \ref predNode().
+    ///tree used in \ref predNode() and \ref predMap().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     Arc predArc(Node v) const { return (*_pred)[v];}
+    ///Returns the 'previous node' of the shortest path tree for a node.
+    ///\brief Returns the 'previous node' of the shortest path tree for
+    ///the given node.
+    ///
     ///This function returns the 'previous node' of the shortest path
     ///tree for the node \c v, i.e. it returns the last but one node
     ///from a shortest path from a root to \c v. It is \c INVALID
+    ///of a shortest path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The shortest path tree used here is equal to the shortest path
     ///tree used in \ref predArc().
+    ///tree used in \ref predArc() and \ref predMap().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     ///
     ///Returns a const reference to the node map that stores the predecessor
     ///arcs, which form the shortest path tree.
+    ///arcs, which form the shortest path tree (forest).
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     const PredMap &predMap() const { return *_pred;}
     ///Checks if a node is reached from the root(s).
+    ///Checks if the given node is reached from the root(s).
     ///Returns \c true if \c v is reached from the root(s).
 …
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
 …
     ///The type of the shortest paths.
     ///It must meet the \ref concepts::Path "Path" concept.
+    ///It must conform to the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
 …
   /// Default traits class used by BfsWizard
+  /// To make it easier to use Bfs algorithm
+  /// we have created a wizard class.
+  /// This \ref BfsWizard class needs default traits,
+  /// as well as the \ref Bfs class.
+  /// The \ref BfsWizardBase is a class to be the default traits of the
+  /// \ref BfsWizard class.
+  /// Default traits class used by BfsWizard.
+  /// \tparam GR The type of the digraph.
   template<class GR>
   class BfsWizardBase : public BfsWizardDefaultTraits<GR>
 …
     /// Constructor.
     /// This constructor does not require parameters, therefore it initiates
+    /// This constructor does not require parameters, it initiates
     /// all of the attributes to \c 0.
     BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
 …
   /// This class should only be used through the \ref bfs() function,
   /// which makes it easier to use the algorithm.
+  ///
+  /// \tparam TR The traits class that defines various types used by the
+  /// algorithm.
   template<class TR>
   class BfsWizard : public TR
 …
     typedef TR Base;
-    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 …
     typedef typename Digraph::OutArcIt OutArcIt;
-    ///\brief The type of the map that stores the predecessor
-    ///arcs of the shortest paths.
     typedef typename TR::PredMap PredMap;
-    ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
-    ///\brief The type of the map that indicates which nodes are reached.
     typedef typename TR::ReachedMap ReachedMap;
-    ///\brief The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
-    ///The type of the shortest paths
     typedef typename TR::Path Path;
 …
     ///Runs BFS algorithm to visit all nodes in the digraph.
     ///This method runs BFS algorithm in order to compute
     ///the shortest path to each node.
+    ///This method runs BFS algorithm in order to visit all nodes
+    ///in the digraph.
     void run()
+    {
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the predecessor map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that stores the predecessor arcs of the nodes.
     template<class T>
     BfsWizard<SetPredMapBase<T> > predMap(const T &t)
 …
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the reached map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that indicates which nodes are reached.
     template<class T>
     BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the distance map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that stores the distances of the nodes calculated
+    ///by the algorithm.
     template<class T>
     BfsWizard<SetDistMapBase<T> > distMap(const T &t)
 …
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///\brief \ref named-func-param "Named parameter" for setting
+    ///the processed map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that indicates which nodes are processed.
     template<class T>
     BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
 …
     ///
     /// The type of the map that indicates which nodes are reached.
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 …
   /// does not observe the BFS events. If you want to observe the BFS
   /// events, you should implement your own visitor class.
   /// \tparam TR Traits class to set various data types used by the
   /// algorithm. The default traits class is
   /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
   /// See \ref BfsVisitDefaultTraits for the documentation of
   /// a BFS visit traits class.
+  /// \tparam TR The traits class that defines various types used by the
+  /// algorithm. By default, it is \ref BfsVisitDefaultTraits
+  /// "BfsVisitDefaultTraits<GR>".
+  /// In most cases, this parameter should not be set directly,
+  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
 …
     /// The simplest way to execute the BFS algorithm is to use one of the
     /// member functions called \ref run(Node) "run()".\n
     /// If you need more control on the execution, first you have to call
     /// \ref init(), then you can add several source nodes with
+    /// If you need better control on the execution, you have to call
+    /// \ref init() first, then you can add several source nodes with
     /// \ref addSource(). Finally the actual path computation can be
     /// performed with one of the \ref start() functions.
 …
     /// \brief Runs the algorithm to visit all nodes in the digraph.
     ///
+    /// This method runs the %BFS algorithm in order to
+    /// compute the shortest path to each node.
+    ///
+    /// The algorithm computes
+    /// - the shortest path tree (forest),
+    /// - the distance of each node from the root(s).
+    /// This method runs the %BFS algorithm in order to visit all nodes
+    /// in the digraph.
     ///
     /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.
 …
     ///@{
     /// \brief Checks if a node is reached from the root(s).
+    /// \brief Checks if the given node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).

lemon/bin_heap.h

-                      r730
+                      r758
 #define LEMON_BIN_HEAP_H
 ///\ingroup auxdat
+///\ingroup heaps
 ///\file
 ///\brief Binary Heap implementation.
+///\brief Binary heap implementation.
 #include <vector>
 …
 namespace lemon {
   ///\ingroup auxdat
+  /// \ingroup heaps
   ///
   ///\brief A Binary Heap implementation.
+  /// \brief Binary heap data structure.
   ///
+  ///This class implements the \e binary \e heap data structure.
+  /// This class implements the \e binary \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
   ///
+  ///A \e heap is a data structure for storing items with specified values
+  ///called \e priorities in such a way that finding the item with minimum
+  ///priority is efficient. \c CMP specifies the ordering of the priorities.
+  ///In a heap one can change the priority of an item, add or erase an
+  ///item, etc.
+  ///
+  ///\tparam PR Type of the priority of the items.
+  ///\tparam IM A read and writable item map with int values, used internally
+  ///to handle the cross references.
+  ///\tparam CMP A functor class for the ordering of the priorities.
+  ///The default is \c std::less<PR>.
+  ///
+  ///\sa FibHeap
+  ///\sa Dijkstra
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
+#ifdef DOXYGEN
+  template <typename PR, typename IM, typename CMP>
+#else
   template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
   class BinHeap {
   public:
+    ///\e
+    /// Type of the item-int map.
     typedef IM ItemIntMap;
     ///\e
+    /// Type of the priorities.
     typedef PR Prio;
     ///\e
+    /// Type of the items stored in the heap.
     typedef typename ItemIntMap::Key Item;
     ///\e
+    /// Type of the item-priority pairs.
     typedef std::pair<Item,Prio> Pair;
     ///\e
+    /// Functor type for comparing the priorities.
     typedef CMP Compare;
     /// \brief Type to represent the items states.
     ///
     /// Each Item element have a state associated to it. It may be "in heap",
     /// "pre heap" or "post heap". The latter two are indifferent from the
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
 …
   public:
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// must be \c PRE_HEAP (<tt>-1</tt>) for every item.
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
     explicit BinHeap(ItemIntMap &map) : _iim(map) {}
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    ///
+    /// \param comp The comparator function object.
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
     BinHeap(ItemIntMap &map, const Compare &comp)
       : _iim(map), _comp(comp) {}
     /// The number of items stored in the heap.
     ///
     /// \brief Returns the number of items stored in the heap.
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
     int size() const { return _data.size(); }
     /// \brief Checks if the heap stores no items.
     ///
     /// Returns \c true if and only if the heap stores no items.
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
     bool empty() const { return _data.empty(); }
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference map.
+    /// If you want to reuse what is not surely empty you should first clear
+    /// the heap and after that you should set the cross reference map for
+    /// each item to \c PRE_HEAP.
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
     void clear() {
       _data.clear();
 …
     static int parent(int i) { return (i-1)/2; }
     static int second_child(int i) { return 2*i+2; }
+    static int secondChild(int i) { return 2*i+2; }
     bool less(const Pair &p1, const Pair &p2) const {
       return _comp(p1.second, p2.second);
+    }
     int bubble_up(int hole, Pair p) {
+    int bubbleUp(int hole, Pair p) {
       int par = parent(hole);
       while( hole>0 && less(p,_data[par]) ) {
 …
+    }
     int bubble_down(int hole, Pair p, int length) {
       int child = second_child(hole);
+    int bubbleDown(int hole, Pair p, int length) {
+      int child = secondChild(hole);
       while(child < length) {
         if( less(_data[child-1], _data[child]) ) {
 …
         move(_data[child], hole);
         hole = child;
         child = second_child(hole);
+        child = secondChild(hole);
+      }
       child--;
 …
   public:
     /// \brief Insert a pair of item and priority into the heap.
     ///
+    /// Adds \c p.first to the heap with priority \c p.second.
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
     /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair &p) {
       int n = _data.size();
       _data.resize(n+1);
+      bubble_up(n, p);
+    }
+    /// \brief Insert an item into the heap with the given heap.
+    ///
+    /// Adds \c i to the heap with priority \c p.
+      bubbleUp(n, p);
+    }
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
     /// \param i The item to insert.
     /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
+    /// \brief Returns the item with minimum priority relative to \c Compare.
+    ///
+    /// This method returns the item with minimum priority relative to \c
+    /// Compare.
+    /// \pre The heap must be nonempty.
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
     Item top() const {
       return _data[0].first;
+    }
     /// \brief Returns the minimum priority relative to \c Compare.
     ///
     /// It returns the minimum priority relative to \c Compare.
     /// \pre The heap must be nonempty.
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
     Prio prio() const {
       return _data[0].second;
+    }
+    /// \brief Deletes the item with minimum priority relative to \c Compare.
+    ///
+    /// This method deletes the item with minimum priority relative to \c
+    /// Compare from the heap.
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
 …
       _iim.set(_data[0].first, POST_HEAP);
       if (n > 0) {
         bubble_down(0, _data[n], n);
+        bubbleDown(0, _data[n], n);
+      }
       _data.pop_back();
+    }
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap.
+    /// \param i The item to erase.
+    /// \pre The item should be in the heap.
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param i The item to delete.
+    /// \pre \e i must be in the heap.
     void erase(const Item &i) {
       int h = _iim[i];
 …
       _iim.set(_data[h].first, POST_HEAP);
       if( h < n ) {
         if ( bubble_up(h, _data[n]) == h) {
           bubble_down(h, _data[n], n);
+        if ( bubbleUp(h, _data[n]) == h) {
+          bubbleDown(h, _data[n], n);
+        }
+      }
 …
+    }
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \param i The item.
+    /// \pre \c i must be in the heap.
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
 …
+    }
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
     /// \param i The item.
     /// \param p The priority.
 …
+      }
       else if( _comp(p, _data[idx].second) ) {
         bubble_up(idx, Pair(i,p));
+        bubbleUp(idx, Pair(i,p));
+      }
       else {
         bubble_down(idx, Pair(i,p), _data.size());
+      }
+    }
     /// \brief Decreases the priority of \c i to \c p.
     ///
     /// This method decreases the priority of item \c i to \c p.
+        bubbleDown(idx, Pair(i,p), _data.size());
+      }
+    }
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \c i must be stored in the heap with priority at least \c
+    /// p relative to \c Compare.
+    /// \pre \e i must be stored in the heap with priority at least \e p.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
       bubble_up(idx, Pair(i,p));
+    }
     /// \brief Increases the priority of \c i to \c p.
     ///
     /// This method sets the priority of item \c i to \c p.
+      bubbleUp(idx, Pair(i,p));
+    }
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
+    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
       bubble_down(idx, Pair(i,p), _data.size());
+    }
     /// \brief Returns if \c item is in, has already been in, or has
     /// never been in the heap.
     ///
     /// This method returns PRE_HEAP if \c item has never been in the
     /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
     /// otherwise. In the latter case it is possible that \c item will
     /// get back to the heap again.
+      bubbleDown(idx, Pair(i,p), _data.size());
+    }
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
 …
+    }
     /// \brief Sets the state of the \c item in the heap.
     ///
     /// Sets the state of the \c item in the heap. It can be used to
     /// manually clear the heap when it is important to achive the
     /// better time complexity.
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
 …
+    }
+    /// \brief Replaces an item in the heap.
+    ///
+    /// The \c i item is replaced with \c j item. The \c i item should
+    /// be in the heap, while the \c j should be out of the heap. The
+    /// \c i item will out of the heap and \c j will be in the heap
+    /// with the same prioriority as prevoiusly the \c i item.
+    /// \brief Replace an item in the heap.
+    ///
+    /// This function replaces item \c i with item \c j.
+    /// Item \c i must be in the heap, while \c j must be out of the heap.
+    /// After calling this method, item \c i will be out of the
+    /// heap and \c j will be in the heap with the same prioriority
+    /// as item \c i had before.
     void replace(const Item& i, const Item& j) {
       int idx = _iim[i];

lemon/bits/edge_set_extender.h

-                      r664
+                      r732
     public:
       ArcMap(const Graph& _g)
+      explicit ArcMap(const Graph& _g)
         : Parent(_g) {}
       ArcMap(const Graph& _g, const _Value& _v)
 …
     public:
       EdgeMap(const Graph& _g)
+      explicit EdgeMap(const Graph& _g)
         : Parent(_g) {}

lemon/bits/graph_extender.h

-                      r664
+                      r825
+    }
     Node fromId(int id, Node) const {
+    static Node fromId(int id, Node) {
       return Parent::nodeFromId(id);
+    }
     Arc fromId(int id, Arc) const {
+    static Arc fromId(int id, Arc) {
       return Parent::arcFromId(id);
+    }
 …
+    }
     Node fromId(int id, Node) const {
+    static Node fromId(int id, Node) {
       return Parent::nodeFromId(id);
+    }
     Arc fromId(int id, Arc) const {
+    static Arc fromId(int id, Arc) {
       return Parent::arcFromId(id);
+    }
     Edge fromId(int id, Edge) const {
+    static Edge fromId(int id, Edge) {
       return Parent::edgeFromId(id);
+    }
 …
     public:
       NodeMap(const Graph& graph)
+      explicit NodeMap(const Graph& graph)
         : Parent(graph) {}
       NodeMap(const Graph& graph, const _Value& value)
 …
     public:
       ArcMap(const Graph& graph)
+      explicit ArcMap(const Graph& graph)
         : Parent(graph) {}
       ArcMap(const Graph& graph, const _Value& value)
 …
     public:
       EdgeMap(const Graph& graph)
+      explicit EdgeMap(const Graph& graph)
         : Parent(graph) {}

lemon/bucket_heap.h

-                      r730
+                      r758
 #define LEMON_BUCKET_HEAP_H
 ///\ingroup auxdat
+///\ingroup heaps
 ///\file
 ///\brief Bucket Heap implementation.
+///\brief Bucket heap implementation.
 #include <vector>
 …
+  }
+  /// \ingroup auxdat
+  ///
+  /// \brief A Bucket Heap implementation.
+  ///
+  /// This class implements the \e bucket \e heap data structure. A \e heap
+  /// is a data structure for storing items with specified values called \e
+  /// priorities in such a way that finding the item with minimum priority is
+  /// efficient. The bucket heap is very simple implementation, it can store
+  /// only integer priorities and it stores for each priority in the
+  /// \f$ [0..C) \f$ range a list of items. So it should be used only when
+  /// the priorities are small. It is not intended to use as dijkstra heap.
+  ///
+  /// \param IM A read and write Item int map, used internally
+  /// to handle the cross references.
+  /// \param MIN If the given parameter is false then instead of the
+  /// minimum value the maximum can be retrivied with the top() and
+  /// prio() member functions.
+  /// \ingroup heaps
+  ///
+  /// \brief Bucket heap data structure.
+  ///
+  /// This class implements the \e bucket \e heap data structure.
+  /// It practically conforms to the \ref concepts::Heap "heap concept",
+  /// but it has some limitations.
+  ///
+  /// The bucket heap is a very simple structure. It can store only
+  /// \c int priorities and it maintains a list of items for each priority
+  /// in the range <tt>[0..C)</tt>. So it should only be used when the
+  /// priorities are small. It is not intended to use as a Dijkstra heap.
+  ///
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
+  /// The default is \e min-heap. If this parameter is set to \c false,
+  /// then the comparison is reversed, so the top(), prio() and pop()
+  /// functions deal with the item having maximum priority instead of the
+  /// minimum.
+  ///
+  /// \sa SimpleBucketHeap
   template <typename IM, bool MIN = true>
   class BucketHeap {
   public:
+    /// \e
+    typedef typename IM::Key Item;
+    /// \e
+    /// Type of the item-int map.
+    typedef IM ItemIntMap;
+    /// Type of the priorities.
     typedef int Prio;
     /// \e
     typedef std::pair<Item, Prio> Pair;
     /// \e
     typedef IM ItemIntMap;
+    /// Type of the items stored in the heap.
+    typedef typename ItemIntMap::Key Item;
+    /// Type of the item-priority pairs.
+    typedef std::pair<Item,Prio> Pair;
   private:
 …
   public:
     /// \brief Type to represent the items states.
     ///
     /// Each Item element have a state associated to it. It may be "in heap",
     /// "pre heap" or "post heap". The latter two are indifferent from the
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
 …
   public:
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
     explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
     /// The number of items stored in the heap.
     ///
     /// \brief Returns the number of items stored in the heap.
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
     int size() const { return _data.size(); }
     /// \brief Checks if the heap stores no items.
     ///
     /// Returns \c true if and only if the heap stores no items.
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
     bool empty() const { return _data.empty(); }
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse a heap what is not surely empty you
+    /// should first clear the heap and after that you should set the
+    /// cross reference map for each item to \c PRE_HEAP.
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
     void clear() {
       _data.clear(); _first.clear(); _minimum = 0;
 …
   private:
     void relocate_last(int idx) {
+    void relocateLast(int idx) {
       if (idx + 1 < int(_data.size())) {
         _data[idx] = _data.back();
 …
   public:
     /// \brief Insert a pair of item and priority into the heap.
     ///
+    /// Adds \c p.first to the heap with priority \c p.second.
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
     /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair& p) {
       push(p.first, p.second);
 …
     /// \brief Insert an item into the heap with the given priority.
     ///
+    /// Adds \c i to the heap with priority \c p.
+    /// This function inserts the given item into the heap with the
+    /// given priority.
     /// \param i The item to insert.
     /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) {
       int idx = _data.size();
 …
+    }
     /// \brief Returns the item with minimum priority.
     ///
     /// This method returns the item with minimum priority.
     /// \pre The heap must be nonempty.
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
     Item top() const {
       while (_first[_minimum] == -1) {
 …
+    }
     /// \brief Returns the minimum priority.
     ///
     /// It returns the minimum priority.
     /// \pre The heap must be nonempty.
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
 …
+    }
     /// \brief Deletes the item with minimum priority.
     ///
     /// This method deletes the item with minimum priority from the heap.
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
 …
       _iim[_data[idx].item] = -2;
       unlace(idx);
+      relocate_last(idx);
+    }
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap, if \c i was
+    /// already stored in the heap.
+    /// \param i The item to erase.
+      relocateLast(idx);
+    }
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param i The item to delete.
+    /// \pre \e i must be in the heap.
     void erase(const Item &i) {
       int idx = _iim[i];
       _iim[_data[idx].item] = -2;
       unlace(idx);
+      relocate_last(idx);
+    }
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
+      relocateLast(idx);
+    }
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
 …
+    }
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
     /// \param i The item.
     /// \param p The priority.
 …
+    }
+    /// \brief Decreases the priority of \c i to \c p.
+    ///
+    /// This method decreases the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at least \c
+    /// p relative to \c Compare.
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at least \e p.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
 …
+    }
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
 …
+    }
     /// \brief Returns if \c item is in, has already been in, or has
     /// never been in the heap.
     ///
     /// This method returns PRE_HEAP if \c item has never been in the
     /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
     /// otherwise. In the latter case it is possible that \c item will
     /// get back to the heap again.
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
 …
+    }
     /// \brief Sets the state of the \c item in the heap.
     ///
     /// Sets the state of the \c item in the heap. It can be used to
     /// manually clear the heap when it is important to achive the
     /// better time complexity.
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
 …
   }; // class BucketHeap
   /// \ingroup auxdat
   ///
   /// \brief A Simplified Bucket Heap implementation.
+  /// \ingroup heaps
+  ///
+  /// \brief Simplified bucket heap data structure.
   ///
   /// This class implements a simplified \e bucket \e heap data
+  /// structure.  It does not provide some functionality but it faster
+  /// and simplier data structure than the BucketHeap. The main
+  /// difference is that the BucketHeap stores for every key a double
+  /// linked list while this class stores just simple lists. In the
+  /// other way it does not support erasing each elements just the
+  /// minimal and it does not supports key increasing, decreasing.
+  ///
+  /// \param IM A read and write Item int map, used internally
+  /// to handle the cross references.
+  /// \param MIN If the given parameter is false then instead of the
+  /// minimum value the maximum can be retrivied with the top() and
+  /// prio() member functions.
+  /// structure. It does not provide some functionality, but it is
+  /// faster and simpler than BucketHeap. The main difference is
+  /// that BucketHeap stores a doubly-linked list for each key while
+  /// this class stores only simply-linked lists. It supports erasing
+  /// only for the item having minimum priority and it does not support
+  /// key increasing and decreasing.
+  ///
+  /// Note that this implementation does not conform to the
+  /// \ref concepts::Heap "heap concept" due to the lack of some
+  /// functionality.
+  ///
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
+  /// The default is \e min-heap. If this parameter is set to \c false,
+  /// then the comparison is reversed, so the top(), prio() and pop()
+  /// functions deal with the item having maximum priority instead of the
+  /// minimum.
   ///
   /// \sa BucketHeap
 …
   public:
+    typedef typename IM::Key Item;
+    /// Type of the item-int map.
+    typedef IM ItemIntMap;
+    /// Type of the priorities.
     typedef int Prio;
+    typedef std::pair<Item, Prio> Pair;
+    typedef IM ItemIntMap;
+    /// Type of the items stored in the heap.
+    typedef typename ItemIntMap::Key Item;
+    /// Type of the item-priority pairs.
+    typedef std::pair<Item,Prio> Pair;
   private:
 …
   public:
     /// \brief Type to represent the items states.
     ///
     /// Each Item element have a state associated to it. It may be "in heap",
     /// "pre heap" or "post heap". The latter two are indifferent from the
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
 …
   public:
     /// \brief The constructor.
     ///
     /// The constructor.
     /// \param map should be given to the constructor, since it is used
     /// internally to handle the cross references. The value of the map
     /// should be PRE_HEAP (-1) for each element.
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
     explicit SimpleBucketHeap(ItemIntMap &map)
       : _iim(map), _free(-1), _num(0), _minimum(0) {}
     /// \brief Returns the number of items stored in the heap.
     ///
     /// The number of items stored in the heap.
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
     int size() const { return _num; }
     /// \brief Checks if the heap stores no items.
     ///
     /// Returns \c true if and only if the heap stores no items.
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
     bool empty() const { return _num == 0; }
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse a heap what is not surely empty you
+    /// should first clear the heap and after that you should set the
+    /// cross reference map for each item to \c PRE_HEAP.
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
     void clear() {
       _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
 …
     /// \brief Insert a pair of item and priority into the heap.
     ///
+    /// Adds \c p.first to the heap with priority \c p.second.
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
     /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair& p) {
       push(p.first, p.second);
 …
     /// \brief Insert an item into the heap with the given priority.
     ///
+    /// Adds \c i to the heap with priority \c p.
+    /// This function inserts the given item into the heap with the
+    /// given priority.
     /// \param i The item to insert.
     /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) {
       int idx;
 …
+    }
     /// \brief Returns the item with minimum priority.
     ///
     /// This method returns the item with minimum priority.
     /// \pre The heap must be nonempty.
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
     Item top() const {
       while (_first[_minimum] == -1) {
 …
+    }
     /// \brief Returns the minimum priority.
     ///
     /// It returns the minimum priority.
     /// \pre The heap must be nonempty.
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
 …
+    }
     /// \brief Deletes the item with minimum priority.
     ///
     /// This method deletes the item with minimum priority from the heap.
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
 …
+    }
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \warning This operator is not a constant time function
+    /// because it scans the whole data structure to find the proper
+    /// value.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
+    /// \warning This operator is not a constant time function because
+    /// it scans the whole data structure to find the proper value.
     Prio operator[](const Item &i) const {
       for (int k = 0; k < _first.size(); ++k) {
+      for (int k = 0; k < int(_first.size()); ++k) {
         int idx = _first[k];
         while (idx != -1) {
 …
+    }
     /// \brief Returns if \c item is in, has already been in, or has
     /// never been in the heap.
     ///
     /// This method returns PRE_HEAP if \c item has never been in the
     /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
     /// otherwise. In the latter case it is possible that \c item will
     /// get back to the heap again.
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
     /// \param i The item.
     State state(const Item &i) const {

lemon/cbc.cc

-                      r623
+                      r793
+  }
+  int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
+    std::vector<int> indexes;
+    std::vector<Value> values;
+    for(ExprIterator it = b; it != e; ++it) {
+      indexes.push_back(it->first);
+      values.push_back(it->second);
+    }
+    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
+    return _prob->numberRows() - 1;
+  }
   void CbcMip::_eraseCol(int i) {

lemon/cbc.h

r623	r793
63	63	virtual int _addCol();
64	64	virtual int _addRow();
	65	virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
65	66
66	67	virtual void _eraseCol(int i);

lemon/circulation.h

-                      r688
+                      r891
     /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
     /// concept.
+#ifdef DOXYGEN
+    typedef GR::ArcMap<Value> FlowMap;
+#else
     typedef typename Digraph::template ArcMap<Value> FlowMap;
+#endif
     /// \brief Instantiates a FlowMap.
 …
     /// The elevator type used by the algorithm.
     ///
+    /// \sa Elevator
+    /// \sa LinkedElevator
+    /// \sa Elevator, LinkedElevator
+#ifdef DOXYGEN
+    typedef lemon::Elevator<GR, GR::Node> Elevator;
+#else
     typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
+#endif
     /// \brief Instantiates an Elevator.
 …
      \tparam SM The type of the supply map. The default map type is
      \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
+     \tparam TR The traits class that defines various types used by the
+     algorithm. By default, it is \ref CirculationDefaultTraits
+     "CirculationDefaultTraits<GR, LM, UM, SM>".
+     In most cases, this parameter should not be set directly,
+     consider to use the named template parameters instead.
   */
 #ifdef DOXYGEN
 …
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
     /// However an external elevator object could also be passed to the
+    /// However, an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
 …
+    }
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
+    Circulation& tolerance(const Tolerance& tolerance) const {
+    /// \brief Sets the tolerance used by the algorithm.
+    ///
+    /// Sets the tolerance object used by the algorithm.
+    /// \return <tt>(*this)</tt>
+    Circulation& tolerance(const Tolerance& tolerance) {
       _tol = tolerance;
       return *this;
 …
     /// \brief Returns a const reference to the tolerance.
     ///
+    /// Returns a const reference to the tolerance.
+    /// Returns a const reference to the tolerance object used by
+    /// the algorithm.
     const Tolerance& tolerance() const {
       return tolerance;
+      return _tol;
+    }
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call \ref run().\n
     /// If you need more control on the initial solution or the execution,
     /// first you have to call one of the \ref init() functions, then
+    /// If you need better control on the initial solution or the execution,
+    /// you have to call one of the \ref init() functions first, then
     /// the \ref start() function.

lemon/clp.cc

-                      r623
+                      r793
+  }
+  int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
+    std::vector<int> indexes;
+    std::vector<Value> values;
+    for(ExprIterator it = b; it != e; ++it) {
+      indexes.push_back(it->first);
+      values.push_back(it->second);
+    }
+    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
+    return _prob->numberRows() - 1;
+  }
   void ClpLp::_eraseCol(int c) {

lemon/clp.h

r623	r793
76	76	virtual int _addCol();
77	77	virtual int _addRow();
	78	virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
78	79
79	80	virtual void _eraseCol(int i);

lemon/concepts/digraph.h

-                      r627
+                      r833
     /// \brief Class describing the concept of directed graphs.
     ///
     /// This class describes the \ref concept "concept" of the
     /// immutable directed digraphs.
+    /// This class describes the common interface of all directed
+    /// graphs (digraphs).
     ///
+    /// Note that actual digraph implementation like @ref ListDigraph or
+    /// @ref SmartDigraph may have several additional functionality.
+    /// Like all concept classes, it only provides an interface
+    /// without any sensible implementation. So any general algorithm for
+    /// directed graphs should compile with this class, but it will not
+    /// run properly, of course.
+    /// An actual digraph implementation like \ref ListDigraph or
+    /// \ref SmartDigraph may have additional functionality.
     ///
     /// \sa concept
+    /// \sa Graph
     class Digraph {
     private:
+      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+      ///
+      Digraph(const Digraph &) {};
+      ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
+      ///\e not allowed. Use DigraphCopy() instead.
+      ///Assignment of \ref Digraph "Digraph"s to another ones are
+      ///\e not allowed.  Use DigraphCopy() instead.
+      /// Diraphs are \e not copy constructible. Use DigraphCopy instead.
+      Digraph(const Digraph &) {}
+      /// \brief Assignment of a digraph to another one is \e not allowed.
+      /// Use DigraphCopy instead.
       void operator=(const Digraph &) {}
     public:
+      ///\e
+      /// Defalult constructor.
+      /// Defalult constructor.
+      ///
+      /// Default constructor.
       Digraph() { }
+      /// Class for identifying a node of the digraph
+      /// The node type of the digraph
       /// This class identifies a node of the digraph. It also serves
       /// as a base class of the node iterators,
       /// thus they will convert to this type.
+      /// thus they convert to this type.
       class Node {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the object to an undefined value.
         Node() { }
         /// Copy constructor.
 …
         Node(const Node&) { }
         /// Invalid constructor \& conversion.
         /// This constructor initializes the iterator to be invalid.
+        /// %Invalid constructor \& conversion.
+        /// Initializes the object to be invalid.
         /// \sa Invalid for more details.
         Node(Invalid) { }
         /// Equality operator
+        /// Equality operator.
+        ///
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
+        /// same object or both are \c INVALID.
         bool operator==(Node) const { return true; }
         /// Inequality operator
+        /// \sa operator==(Node n)
+        ///
+        /// Inequality operator.
         bool operator!=(Node) const { return true; }
         /// Artificial ordering operator.
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        /// Artificial ordering operator.
+        ///
+        /// \note This operator only has to define some strict ordering of
+        /// the nodes; this order has nothing to do with the iteration
+        /// ordering of the nodes.
         bool operator<(Node) const { return false; }
+      };
+      /// This iterator goes through each node.
+      /// This iterator goes through each node.
+      /// Its usage is quite simple, for example you can count the number
+      /// of nodes in digraph \c g of type \c Digraph like this:
+      };
+      /// Iterator class for the nodes.
+      /// This iterator goes through each node of the digraph.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of nodes in a digraph \c g of type \c %Digraph like this:
       ///\code
       /// int count=0;
 …
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         NodeIt() { }
         /// Copy constructor.
 …
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
         /// Invalid constructor \& conversion.
         /// Initialize the iterator to be invalid.
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
         /// \sa Invalid for more details.
         NodeIt(Invalid) { }
         /// Sets the iterator to the first node.
+        /// Sets the iterator to the first node of \c g.
+        ///
+        NodeIt(const Digraph&) { }
+        /// Node -> NodeIt conversion.
+        /// Sets the iterator to the node of \c the digraph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the first node of the given digraph.
+        ///
+        explicit NodeIt(const Digraph&) { }
+        /// Sets the iterator to the given node.
+        /// Sets the iterator to the given node of the given digraph.
+        ///
         NodeIt(const Digraph&, const Node&) { }
         /// Next node.
 …
       /// Class for identifying an arc of the digraph
+      /// The arc type of the digraph
       /// This class identifies an arc of the digraph. It also serves
 …
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the object to an undefined value.
         Arc() { }
         /// Copy constructor.
 …
         ///
         Arc(const Arc&) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the object to be invalid.
+        /// \sa Invalid for more details.
         Arc(Invalid) { }
         /// Equality operator
+        /// Equality operator.
+        ///
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
+        /// same object or both are \c INVALID.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
+        /// \sa operator==(Arc n)
+        ///
+        /// Inequality operator.
         bool operator!=(Arc) const { return true; }
         /// Artificial ordering operator.
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        /// Artificial ordering operator.
+        ///
+        /// \note This operator only has to define some strict ordering of
+        /// the arcs; this order has nothing to do with the iteration
+        /// ordering of the arcs.
         bool operator<(Arc) const { return false; }
       };
       /// This iterator goes trough the outgoing arcs of a node.
+      /// Iterator class for the outgoing arcs of a node.
       /// This iterator goes trough the \e outgoing arcs of a certain node
       /// of a digraph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of outgoing arcs of a node \c n
       /// in digraph \c g of type \c Digraph as follows.
+      /// in a digraph \c g of type \c %Digraph as follows.
       ///\code
       /// int count=0;
       /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
+      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
       ///\endcode
       class OutArcIt : public Arc {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
 …
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         OutArcIt(Invalid) { }
         /// This constructor sets the iterator to the first outgoing arc.
         /// This constructor sets the iterator to the first outgoing arc of
         /// the node.
+        /// Sets the iterator to the first outgoing arc.
+        /// Sets the iterator to the first outgoing arc of the given node.
+        ///
         OutArcIt(const Digraph&, const Node&) { }
+        /// Arc -> OutArcIt conversion
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the given arc.
+        /// Sets the iterator to the given arc of the given digraph.
+        ///
         OutArcIt(const Digraph&, const Arc&) { }
         ///Next outgoing arc
+        /// Next outgoing arc
         /// Assign the iterator to the next
 …
       };
       /// This iterator goes trough the incoming arcs of a node.
+      /// Iterator class for the incoming arcs of a node.
       /// This iterator goes trough the \e incoming arcs of a certain node
       /// of a digraph.
       /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
       /// in digraph \c g of type \c Digraph as follows.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of incoming arcs of a node \c n
+      /// in a digraph \c g of type \c %Digraph as follows.
       ///\code
       /// int count=0;
       /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
+      /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
       ///\endcode
       class InArcIt : public Arc {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         InArcIt() { }
         /// Copy constructor.
 …
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         InArcIt(Invalid) { }
         /// This constructor sets the iterator to first incoming arc.
         /// This constructor set the iterator to the first incoming arc of
         /// the node.
+        /// Sets the iterator to the first incoming arc.
+        /// Sets the iterator to the first incoming arc of the given node.
+        ///
         InArcIt(const Digraph&, const Node&) { }
+        /// Arc -> InArcIt conversion
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the given arc.
+        /// Sets the iterator to the given arc of the given digraph.
+        ///
         InArcIt(const Digraph&, const Arc&) { }
         /// Next incoming arc
         /// Assign the iterator to the next inarc of the corresponding node.
         ///
+        /// Assign the iterator to the next
+        /// incoming arc of the corresponding node.
         InArcIt& operator++() { return *this; }
       };
+      /// This iterator goes through each arc.
+      /// This iterator goes through each arc of a digraph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of arcs in a digraph \c g of type \c Digraph as follows:
+      /// Iterator class for the arcs.
+      /// This iterator goes through each arc of the digraph.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of arcs in a digraph \c g of type \c %Digraph as follows:
       ///\code
       /// int count=0;
       /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
+      /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
       ///\endcode
       class ArcIt : public Arc {
 …
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         ArcIt() { }
         /// Copy constructor.
 …
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         ArcIt(Invalid) { }
+        /// This constructor sets the iterator to the first arc.
+        /// This constructor sets the iterator to the first arc of \c g.
+        ///@param g the digraph
+        ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
+        /// Arc -> ArcIt conversion
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the first arc.
+        /// Sets the iterator to the first arc of the given digraph.
+        ///
+        explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
+        /// Sets the iterator to the given arc.
+        /// Sets the iterator to the given arc of the given digraph.
+        ///
         ArcIt(const Digraph&, const Arc&) { }
         ///Next arc
+        /// Next arc
         /// Assign the iterator to the next arc.
+        ///
         ArcIt& operator++() { return *this; }
       };
+      ///Gives back the target node of an arc.
+      ///Gives back the target node of an arc.
+      ///
+      /// \brief The source node of the arc.
+      ///
+      /// Returns the source node of the given arc.
+      Node source(Arc) const { return INVALID; }
+      /// \brief The target node of the arc.
+      ///
+      /// Returns the target node of the given arc.
       Node target(Arc) const { return INVALID; }
+      ///Gives back the source node of an arc.
+      ///Gives back the source node of an arc.
+      ///
+      Node source(Arc) const { return INVALID; }
+      /// \brief Returns the ID of the node.
+      /// \brief The ID of the node.
+      ///
+      /// Returns the ID of the given node.
       int id(Node) const { return -1; }
+      /// \brief Returns the ID of the arc.
+      /// \brief The ID of the arc.
+      ///
+      /// Returns the ID of the given arc.
       int id(Arc) const { return -1; }
+      /// \brief Returns the node with the given ID.
+      ///
+      /// \pre The argument should be a valid node ID in the graph.
+      /// \brief The node with the given ID.
+      ///
+      /// Returns the node with the given ID.
+      /// \pre The argument should be a valid node ID in the digraph.
       Node nodeFromId(int) const { return INVALID; }
+      /// \brief Returns the arc with the given ID.
+      ///
+      /// \pre The argument should be a valid arc ID in the graph.
+      /// \brief The arc with the given ID.
+      ///
+      /// Returns the arc with the given ID.
+      /// \pre The argument should be a valid arc ID in the digraph.
       Arc arcFromId(int) const { return INVALID; }
+      /// \brief Returns an upper bound on the node IDs.
+      /// \brief An upper bound on the node IDs.
+      ///
+      /// Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
+      /// \brief Returns an upper bound on the arc IDs.
+      /// \brief An upper bound on the arc IDs.
+      ///
+      /// Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
 …
       int maxId(Arc) const { return -1; }
+      /// \brief The opposite node on the arc.
+      ///
+      /// Returns the opposite node on the given arc.
+      Node oppositeNode(Node, Arc) const { return INVALID; }
       /// \brief The base node of the iterator.
       ///
       /// Gives back the base node of the iterator.
       /// It is always the target of the pointed arc.
       Node baseNode(const InArcIt&) const { return INVALID; }
+      /// Returns the base node of the given outgoing arc iterator
+      /// (i.e. the source node of the corresponding arc).
+      Node baseNode(OutArcIt) const { return INVALID; }
       /// \brief The running node of the iterator.
       ///
       /// Gives back the running node of the iterator.
       /// It is always the source of the pointed arc.
       Node runningNode(const InArcIt&) const { return INVALID; }
+      /// Returns the running node of the given outgoing arc iterator
+      /// (i.e. the target node of the corresponding arc).
+      Node runningNode(OutArcIt) const { return INVALID; }
       /// \brief The base node of the iterator.
       ///
       /// Gives back the base node of the iterator.
       /// It is always the source of the pointed arc.
       Node baseNode(const OutArcIt&) const { return INVALID; }
+      /// Returns the base node of the given incomming arc iterator
+      /// (i.e. the target node of the corresponding arc).
+      Node baseNode(InArcIt) const { return INVALID; }
       /// \brief The running node of the iterator.
       ///
+      /// Gives back the running node of the iterator.
+      /// It is always the target of the pointed arc.
+      Node runningNode(const OutArcIt&) const { return INVALID; }
+      /// \brief The opposite node on the given arc.
+      ///
+      /// Gives back the opposite node on the given arc.
+      Node oppositeNode(const Node&, const Arc&) const { return INVALID; }
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
+      /// Returns the running node of the given incomming arc iterator
+      /// (i.e. the source node of the corresponding arc).
+      Node runningNode(InArcIt) const { return INVALID; }
+      /// \brief Standard graph map type for the nodes.
+      ///
+      /// Standard graph map type for the nodes.
+      /// It conforms to the ReferenceMap concept.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
       public:
         ///\e
         NodeMap(const Digraph&) { }
         ///\e
+        /// Constructor
+        explicit NodeMap(const Digraph&) { }
+        /// Constructor with given initial value
         NodeMap(const Digraph&, T) { }
 …
       };
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
+      /// \brief Standard graph map type for the arcs.
+      ///
+      /// Standard graph map type for the arcs.
+      /// It conforms to the ReferenceMap concept.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
       public:
         ///\e
         ArcMap(const Digraph&) { }
         ///\e
+        /// Constructor
+        explicit ArcMap(const Digraph&) { }
+        /// Constructor with given initial value
         ArcMap(const Digraph&, T) { }
       private:
         ///Copy constructor

lemon/concepts/graph.h

-                      r704
+                      r833
 ///\ingroup graph_concepts
 ///\file
 ///\brief The concept of Undirected Graphs.
+///\brief The concept of undirected graphs.
 #ifndef LEMON_CONCEPTS_GRAPH_H
 …
 #include <lemon/concepts/graph_components.h>
+#include <lemon/concepts/maps.h>
+#include <lemon/concept_check.h>
 #include <lemon/core.h>
 …
     /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Undirected Graphs.
+    /// \brief Class describing the concept of undirected graphs.
     ///
     /// This class describes the common interface of all Undirected
     /// Graphs.
+    /// This class describes the common interface of all undirected
+    /// graphs.
     ///
     /// As all concept describing classes it provides only interface
     /// without any sensible implementation. So any algorithm for
     /// undirected graph should compile with this class, but it will not
+    /// Like all concept classes, it only provides an interface
+    /// without any sensible implementation. So any general algorithm for
+    /// undirected graphs should compile with this class, but it will not
     /// run properly, of course.
+    /// An actual graph implementation like \ref ListGraph or
+    /// \ref SmartGraph may have additional functionality.
     ///
+    /// The LEMON undirected graphs also fulfill the concept of
+    /// directed graphs (\ref lemon::concepts::Digraph "Digraph
+    /// Concept"). Each edges can be seen as two opposite
+    /// directed arc and consequently the undirected graph can be
+    /// seen as the direceted graph of these directed arcs. The
+    /// Graph has the Edge inner class for the edges and
+    /// the Arc type for the directed arcs. The Arc type is
+    /// convertible to Edge or inherited from it so from a directed
+    /// arc we can get the represented edge.
+    /// The undirected graphs also fulfill the concept of \ref Digraph
+    /// "directed graphs", since each edge can also be regarded as two
+    /// oppositely directed arcs.
+    /// Undirected graphs provide an Edge type for the undirected edges and
+    /// an Arc type for the directed arcs. The Arc type is convertible to
+    /// Edge or inherited from it, i.e. the corresponding edge can be
+    /// obtained from an arc.
+    /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt
+    /// and ArcMap classes can be used for the arcs (just like in digraphs).
+    /// Both InArcIt and OutArcIt iterates on the same edges but with
+    /// opposite direction. IncEdgeIt also iterates on the same edges
+    /// as OutArcIt and InArcIt, but it is not convertible to Arc,
+    /// only to Edge.
     ///
+    /// In the sense of the LEMON each edge has a default
+    /// direction (it should be in every computer implementation,
+    /// because the order of edge's nodes defines an
+    /// orientation). With the default orientation we can define that
+    /// the directed arc is forward or backward directed. With the \c
+    /// direction() and \c direct() function we can get the direction
+    /// of the directed arc and we can direct an edge.
+    /// In LEMON, each undirected edge has an inherent orientation.
+    /// Thus it can defined if an arc is forward or backward oriented in
+    /// an undirected graph with respect to this default oriantation of
+    /// the represented edge.
+    /// With the direction() and direct() functions the direction
+    /// of an arc can be obtained and set, respectively.
     ///
+    /// The EdgeIt is an iterator for the edges. We can use
+    /// the EdgeMap to map values for the edges. The InArcIt and
+    /// OutArcIt iterates on the same edges but with opposite
+    /// direction. The IncEdgeIt iterates also on the same edges
+    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
+    /// to Edge.
+    /// Only nodes and edges can be added to or removed from an undirected
+    /// graph and the corresponding arcs are added or removed automatically.
+    ///
+    /// \sa Digraph
     class Graph {
+    private:
+      /// Graphs are \e not copy constructible. Use DigraphCopy instead.
+      Graph(const Graph&) {}
+      /// \brief Assignment of a graph to another one is \e not allowed.
+      /// Use DigraphCopy instead.
+      void operator=(const Graph&) {}
     public:
+      /// \brief The undirected graph should be tagged by the
+      /// UndirectedTag.
+      ///
+      /// The undirected graph should be tagged by the UndirectedTag. This
+      /// tag helps the enable_if technics to make compile time
+      /// Default constructor.
+      Graph() {}
+      /// \brief Undirected graphs should be tagged with \c UndirectedTag.
+      ///
+      /// Undirected graphs should be tagged with \c UndirectedTag.
+      ///
+      /// This tag helps the \c enable_if technics to make compile time
       /// specializations for undirected graphs.
       typedef True UndirectedTag;
+      /// \brief The base type of node iterators,
+      /// or in other words, the trivial node iterator.
+      ///
+      /// This is the base type of each node iterator,
+      /// thus each kind of node iterator converts to this.
+      /// More precisely each kind of node iterator should be inherited
+      /// from the trivial node iterator.
+      /// The node type of the graph
+      /// This class identifies a node of the graph. It also serves
+      /// as a base class of the node iterators,
+      /// thus they convert to this type.
       class Node {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the object to an undefined value.
         Node() { }
         /// Copy constructor.
 …
         Node(const Node&) { }
         /// Invalid constructor \& conversion.
         /// This constructor initializes the iterator to be invalid.
+        /// %Invalid constructor \& conversion.
+        /// Initializes the object to be invalid.
         /// \sa Invalid for more details.
         Node(Invalid) { }
         /// Equality operator
+        /// Equality operator.
+        ///
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
+        /// same object or both are \c INVALID.
         bool operator==(Node) const { return true; }
         /// Inequality operator
+        /// \sa operator==(Node n)
+        ///
+        /// Inequality operator.
         bool operator!=(Node) const { return true; }
         /// Artificial ordering operator.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// Artificial ordering operator.
+        ///
+        /// \note This operator only has to define some strict ordering of
         /// the items; this order has nothing to do with the iteration
         /// ordering of the items.
 …
       };
       /// This iterator goes through each node.
       /// This iterator goes through each node.
       /// Its usage is quite simple, for example you can count the number
       /// of nodes in graph \c g of type \c Graph like this:
+      /// Iterator class for the nodes.
+      /// This iterator goes through each node of the graph.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of nodes in a graph \c g of type \c %Graph like this:
       ///\code
       /// int count=0;
 …
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         NodeIt() { }
         /// Copy constructor.
 …
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
         /// Invalid constructor \& conversion.
         /// Initialize the iterator to be invalid.
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
         /// \sa Invalid for more details.
         NodeIt(Invalid) { }
         /// Sets the iterator to the first node.
+        /// Sets the iterator to the first node of \c g.
+        ///
+        NodeIt(const Graph&) { }
+        /// Node -> NodeIt conversion.
+        /// Sets the iterator to the node of \c the graph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the first node of the given digraph.
+        ///
+        explicit NodeIt(const Graph&) { }
+        /// Sets the iterator to the given node.
+        /// Sets the iterator to the given node of the given digraph.
+        ///
         NodeIt(const Graph&, const Node&) { }
         /// Next node.
 …
+      /// The base type of the edge iterators.
+      /// The base type of the edge iterators.
+      ///
+      /// The edge type of the graph
+      /// This class identifies an edge of the graph. It also serves
+      /// as a base class of the edge iterators,
+      /// thus they will convert to this type.
       class Edge {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the object to an undefined value.
         Edge() { }
         /// Copy constructor.
 …
         ///
         Edge(const Edge&) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the object to be invalid.
+        /// \sa Invalid for more details.
         Edge(Invalid) { }
         /// Equality operator
+        /// Equality operator.
+        ///
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
+        /// same object or both are \c INVALID.
         bool operator==(Edge) const { return true; }
         /// Inequality operator
+        /// \sa operator==(Edge n)
+        ///
+        /// Inequality operator.
         bool operator!=(Edge) const { return true; }
         /// Artificial ordering operator.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        /// Artificial ordering operator.
+        ///
+        /// \note This operator only has to define some strict ordering of
+        /// the edges; this order has nothing to do with the iteration
+        /// ordering of the edges.
         bool operator<(Edge) const { return false; }
       };
       /// This iterator goes through each edge.
       /// This iterator goes through each edge of a graph.
       /// Its usage is quite simple, for example you can count the number
       /// of edges in a graph \c g of type \c Graph as follows:
+      /// Iterator class for the edges.
+      /// This iterator goes through each edge of the graph.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of edges in a graph \c g of type \c %Graph as follows:
       ///\code
       /// int count=0;
 …
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         EdgeIt() { }
         /// Copy constructor.
 …
         ///
         EdgeIt(const EdgeIt& e) : Edge(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         EdgeIt(Invalid) { }
+        /// This constructor sets the iterator to the first edge.
+        /// This constructor sets the iterator to the first edge.
+        EdgeIt(const Graph&) { }
+        /// Edge -> EdgeIt conversion
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the edge-set, the iteration order is the
+        /// same.
+        /// Sets the iterator to the first edge.
+        /// Sets the iterator to the first edge of the given graph.
+        ///
+        explicit EdgeIt(const Graph&) { }
+        /// Sets the iterator to the given edge.
+        /// Sets the iterator to the given edge of the given graph.
+        ///
         EdgeIt(const Graph&, const Edge&) { }
         /// Next edge
         /// Assign the iterator to the next edge.
+        ///
         EdgeIt& operator++() { return *this; }
       };
+      /// \brief This iterator goes trough the incident undirected
+      /// arcs of a node.
+      ///
+      /// This iterator goes trough the incident edges
+      /// of a certain node of a graph. You should assume that the
+      /// loop arcs will be iterated twice.
+      ///
+      /// Its usage is quite simple, for example you can compute the
+      /// degree (i.e. count the number of incident arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
+      /// Iterator class for the incident edges of a node.
+      /// This iterator goes trough the incident undirected edges
+      /// of a certain node of a graph.
+      /// Its usage is quite simple, for example, you can compute the
+      /// degree (i.e. the number of incident edges) of a node \c n
+      /// in a graph \c g of type \c %Graph as follows.
       ///
       ///\code
 …
       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+      ///
+      /// \warning Loop edges will be iterated twice.
       class IncEdgeIt : public Edge {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         IncEdgeIt() { }
         /// Copy constructor.
 …
         ///
         IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         IncEdgeIt(Invalid) { }
         /// This constructor sets the iterator to first incident arc.
         /// This constructor set the iterator to the first incident arc of
         /// the node.
+        /// Sets the iterator to the first incident edge.
+        /// Sets the iterator to the first incident edge of the given node.
+        ///
         IncEdgeIt(const Graph&, const Node&) { }
+        /// Edge -> IncEdgeIt conversion
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the given edge.
+        /// Sets the iterator to the given edge of the given graph.
+        ///
         IncEdgeIt(const Graph&, const Edge&) { }
         /// Next incident arc
         /// Assign the iterator to the next incident arc
+        /// Next incident edge
+        /// Assign the iterator to the next incident edge
         /// of the corresponding node.
         IncEdgeIt& operator++() { return *this; }
       };
       /// The directed arc type.
       /// The directed arc type. It can be converted to the
       /// edge or it should be inherited from the undirected
       /// edge.
+      /// The arc type of the graph
+      /// This class identifies a directed arc of the graph. It also serves
+      /// as a base class of the arc iterators,
+      /// thus they will convert to this type.
       class Arc {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the object to an undefined value.
         Arc() { }
         /// Copy constructor.
 …
         ///
         Arc(const Arc&) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the object to be invalid.
+        /// \sa Invalid for more details.
         Arc(Invalid) { }
         /// Equality operator
+        /// Equality operator.
+        ///
         /// Two iterators are equal if and only if they point to the
         /// same object or both are invalid.
+        /// same object or both are \c INVALID.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
+        /// \sa operator==(Arc n)
+        ///
+        /// Inequality operator.
         bool operator!=(Arc) const { return true; }
         /// Artificial ordering operator.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
+        /// Artificial ordering operator.
+        ///
+        /// \note This operator only has to define some strict ordering of
+        /// the arcs; this order has nothing to do with the iteration
+        /// ordering of the arcs.
         bool operator<(Arc) const { return false; }
+        /// Converison to Edge
+        /// Converison to \c Edge
+        /// Converison to \c Edge.
+        ///
         operator Edge() const { return Edge(); }
       };
+      /// This iterator goes through each directed arc.
+      /// This iterator goes through each arc of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of arcs in a graph \c g of type \c Graph as follows:
+      /// Iterator class for the arcs.
+      /// This iterator goes through each directed arc of the graph.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of arcs in a graph \c g of type \c %Graph as follows:
       ///\code
       /// int count=0;
       /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
+      /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
       ///\endcode
       class ArcIt : public Arc {
 …
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         ArcIt() { }
         /// Copy constructor.
 …
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         ArcIt(Invalid) { }
+        /// This constructor sets the iterator to the first arc.
+        /// This constructor sets the iterator to the first arc of \c g.
+        ///@param g the graph
+        ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
+        /// Arc -> ArcIt conversion
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the first arc.
+        /// Sets the iterator to the first arc of the given graph.
+        ///
+        explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
+        /// Sets the iterator to the given arc.
+        /// Sets the iterator to the given arc of the given graph.
+        ///
         ArcIt(const Graph&, const Arc&) { }
         ///Next arc
+        /// Next arc
         /// Assign the iterator to the next arc.
+        ///
         ArcIt& operator++() { return *this; }
       };
       /// This iterator goes trough the outgoing directed arcs of a node.
       /// This iterator goes trough the \e outgoing arcs of a certain node
       /// of a graph.
       /// Its usage is quite simple, for example you can count the number
+      /// Iterator class for the outgoing arcs of a node.
+      /// This iterator goes trough the \e outgoing directed arcs of a
+      /// certain node of a graph.
+      /// Its usage is quite simple, for example, you can count the number
       /// of outgoing arcs of a node \c n
       /// in graph \c g of type \c Graph as follows.
+      /// in a graph \c g of type \c %Graph as follows.
       ///\code
       /// int count=0;
       /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
+      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
       ///\endcode
       class OutArcIt : public Arc {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
 …
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         OutArcIt(Invalid) { }
+        /// This constructor sets the iterator to the first outgoing arc.
+        /// This constructor sets the iterator to the first outgoing arc of
+        /// the node.
+        ///@param n the node
+        ///@param g the graph
+        /// Sets the iterator to the first outgoing arc.
+        /// Sets the iterator to the first outgoing arc of the given node.
+        ///
         OutArcIt(const Graph& n, const Node& g) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
+        }
+        /// Arc -> OutArcIt conversion
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the given arc.
+        /// Sets the iterator to the given arc of the given graph.
+        ///
         OutArcIt(const Graph&, const Arc&) { }
         ///Next outgoing arc
+        /// Next outgoing arc
         /// Assign the iterator to the next
 …
       };
       /// This iterator goes trough the incoming directed arcs of a node.
       /// This iterator goes trough the \e incoming arcs of a certain node
       /// of a graph.
       /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
       /// in graph \c g of type \c Graph as follows.
+      /// Iterator class for the incoming arcs of a node.
+      /// This iterator goes trough the \e incoming directed arcs of a
+      /// certain node of a graph.
+      /// Its usage is quite simple, for example, you can count the number
+      /// of incoming arcs of a node \c n
+      /// in a graph \c g of type \c %Graph as follows.
       ///\code
       /// int count=0;
       /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
+      /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
       ///\endcode
       class InArcIt : public Arc {
       public:
         /// Default constructor
         /// @warning The default constructor sets the iterator
         /// to an undefined value.
+        /// Default constructor.
+        /// \warning It sets the iterator to an undefined value.
         InArcIt() { }
         /// Copy constructor.
 …
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
         /// Initialize the iterator to be invalid.
         /// Initialize the iterator to be invalid.
         ///
+        /// %Invalid constructor \& conversion.
+        /// Initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
         InArcIt(Invalid) { }
+        /// This constructor sets the iterator to first incoming arc.
+        /// This constructor set the iterator to the first incoming arc of
+        /// the node.
+        ///@param n the node
+        ///@param g the graph
+        /// Sets the iterator to the first incoming arc.
+        /// Sets the iterator to the first incoming arc of the given node.
+        ///
         InArcIt(const Graph& g, const Node& n) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
+        }
+        /// Arc -> InArcIt conversion
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
+        /// Sets the iterator to the given arc.
+        /// Sets the iterator to the given arc of the given graph.
+        ///
         InArcIt(const Graph&, const Arc&) { }
         /// Next incoming arc
         /// Assign the iterator to the next inarc of the corresponding node.
         ///
+        /// Assign the iterator to the next
+        /// incoming arc of the corresponding node.
         InArcIt& operator++() { return *this; }
       };
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
+      /// \brief Standard graph map type for the nodes.
+      ///
+      /// Standard graph map type for the nodes.
+      /// It conforms to the ReferenceMap concept.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&>
 …
       public:
         ///\e
         NodeMap(const Graph&) { }
         ///\e
+        /// Constructor
+        explicit NodeMap(const Graph&) { }
+        /// Constructor with given initial value
         NodeMap(const Graph&, T) { }
 …
       };
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
+      /// \brief Standard graph map type for the arcs.
+      ///
+      /// Standard graph map type for the arcs.
+      /// It conforms to the ReferenceMap concept.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
 …
       public:
         ///\e
         ArcMap(const Graph&) { }
         ///\e
+        /// Constructor
+        explicit ArcMap(const Graph&) { }
+        /// Constructor with given initial value
         ArcMap(const Graph&, T) { }
       private:
         ///Copy constructor
 …
       };
+      /// Reference map of the edges to type \c T.
+      /// Reference map of the edges to type \c T.
+      /// \brief Standard graph map type for the edges.
+      ///
+      /// Standard graph map type for the edges.
+      /// It conforms to the ReferenceMap concept.
       template<class T>
       class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
 …
       public:
         ///\e
         EdgeMap(const Graph&) { }
         ///\e
+        /// Constructor
+        explicit EdgeMap(const Graph&) { }
+        /// Constructor with given initial value
         EdgeMap(const Graph&, T) { }
       private:
         ///Copy constructor
 …
       };
+      /// \brief Direct the given edge.
+      ///
+      /// Direct the given edge. The returned arc source
+      /// will be the given node.
+      Arc direct(const Edge&, const Node&) const {
+        return INVALID;
+      }
+      /// \brief Direct the given edge.
+      ///
+      /// Direct the given edge. The returned arc
+      /// represents the given edge and the direction comes
+      /// from the bool parameter. The source of the edge and
+      /// the directed arc is the same when the given bool is true.
+      Arc direct(const Edge&, bool) const {
+        return INVALID;
+      }
+      /// \brief Returns true if the arc has default orientation.
+      ///
+      /// Returns whether the given directed arc is same orientation as
+      /// the corresponding edge's default orientation.
+      bool direction(Arc) const { return true; }
+      /// \brief Returns the opposite directed arc.
+      ///
+      /// Returns the opposite directed arc.
+      Arc oppositeArc(Arc) const { return INVALID; }
+      /// \brief Opposite node on an arc
+      ///
+      /// \return The opposite of the given node on the given edge.
+      Node oppositeNode(Node, Edge) const { return INVALID; }
+      /// \brief First node of the edge.
+      ///
+      /// \return The first node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
+      /// \brief The first node of the edge.
+      ///
+      /// Returns the first node of the given edge.
+      ///
+      /// Edges don't have source and target nodes, however, methods
+      /// u() and v() are used to query the two end-nodes of an edge.
+      /// The orientation of an edge that arises this way is called
+      /// the inherent direction, it is used to define the default
+      /// direction for the corresponding arcs.
       /// \sa v()
       /// \sa direction()
       Node u(Edge) const { return INVALID; }
+      /// \brief Second node of the edge.
+      ///
+      /// \return The second node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
+      /// \brief The second node of the edge.
+      ///
+      /// Returns the second node of the given edge.
+      ///
+      /// Edges don't have source and target nodes, however, methods
+      /// u() and v() are used to query the two end-nodes of an edge.
+      /// The orientation of an edge that arises this way is called
+      /// the inherent direction, it is used to define the default
+      /// direction for the corresponding arcs.
       /// \sa u()
       /// \sa direction()
       Node v(Edge) const { return INVALID; }
+      /// \brief Source node of the directed arc.
+      /// \brief The source node of the arc.
+      ///
+      /// Returns the source node of the given arc.
       Node source(Arc) const { return INVALID; }
+      /// \brief Target node of the directed arc.
+      /// \brief The target node of the arc.
+      ///
+      /// Returns the target node of the given arc.
       Node target(Arc) const { return INVALID; }
+      /// \brief Returns the id of the node.
+      /// \brief The ID of the node.
+      ///
+      /// Returns the ID of the given node.
       int id(Node) const { return -1; }
+      /// \brief Returns the id of the edge.
+      /// \brief The ID of the edge.
+      ///
+      /// Returns the ID of the given edge.
       int id(Edge) const { return -1; }
+      /// \brief Returns the id of the arc.
+      /// \brief The ID of the arc.
+      ///
+      /// Returns the ID of the given arc.
       int id(Arc) const { return -1; }
+      /// \brief Returns the node with the given id.
+      ///
+      /// \pre The argument should be a valid node id in the graph.
+      /// \brief The node with the given ID.
+      ///
+      /// Returns the node with the given ID.
+      /// \pre The argument should be a valid node ID in the graph.
       Node nodeFromId(int) const { return INVALID; }
+      /// \brief Returns the edge with the given id.
+      ///
+      /// \pre The argument should be a valid edge id in the graph.
+      /// \brief The edge with the given ID.
+      ///
+      /// Returns the edge with the given ID.
+      /// \pre The argument should be a valid edge ID in the graph.
       Edge edgeFromId(int) const { return INVALID; }
+      /// \brief Returns the arc with the given id.
+      ///
+      /// \pre The argument should be a valid arc id in the graph.
+      /// \brief The arc with the given ID.
+      ///
+      /// Returns the arc with the given ID.
+      /// \pre The argument should be a valid arc ID in the graph.
       Arc arcFromId(int) const { return INVALID; }
+      /// \brief Returns an upper bound on the node IDs.
+      /// \brief An upper bound on the node IDs.
+      ///
+      /// Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
+      /// \brief Returns an upper bound on the edge IDs.
+      /// \brief An upper bound on the edge IDs.
+      ///
+      /// Returns an upper bound on the edge IDs.
       int maxEdgeId() const { return -1; }
+      /// \brief Returns an upper bound on the arc IDs.
+      /// \brief An upper bound on the arc IDs.
+      ///
+      /// Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
+      /// \brief The direction of the arc.
+      ///
+      /// Returns \c true if the direction of the given arc is the same as
+      /// the inherent orientation of the represented edge.
+      bool direction(Arc) const { return true; }
+      /// \brief Direct the edge.
+      ///
+      /// Direct the given edge. The returned arc
+      /// represents the given edge and its direction comes
+      /// from the bool parameter. If it is \c true, then the direction
+      /// of the arc is the same as the inherent orientation of the edge.
+      Arc direct(Edge, bool) const {
+        return INVALID;
+      }
+      /// \brief Direct the edge.
+      ///
+      /// Direct the given edge. The returned arc represents the given
+      /// edge and its source node is the given node.
+      Arc direct(Edge, Node) const {
+        return INVALID;
+      }
+      /// \brief The oppositely directed arc.
+      ///
+      /// Returns the oppositely directed arc representing the same edge.
+      Arc oppositeArc(Arc) const { return INVALID; }
+      /// \brief The opposite node on the edge.
+      ///
+      /// Returns the opposite node on the given edge.
+      Node oppositeNode(Node, Edge) const { return INVALID; }
       void first(Node&) const {}
 …
       int maxId(Arc) const { return -1; }
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node (the source in this case) of the iterator
+      Node baseNode(OutArcIt e) const {
+        return source(e);
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node (the target in this case) of the
+      /// iterator
+      Node runningNode(OutArcIt e) const {
+        return target(e);
+      }
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node (the target in this case) of the iterator
+      Node baseNode(InArcIt e) const {
+        return target(e);
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node (the source in this case) of the
+      /// iterator
+      Node runningNode(InArcIt e) const {
+        return source(e);
+      }
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node of the iterator
+      Node baseNode(IncEdgeIt) const {
+        return INVALID;
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node of the iterator
+      Node runningNode(IncEdgeIt) const {
+        return INVALID;
+      }
+      /// \brief The base node of the iterator.
+      ///
+      /// Returns the base node of the given incident edge iterator.
+      Node baseNode(IncEdgeIt) const { return INVALID; }
+      /// \brief The running node of the iterator.
+      ///
+      /// Returns the running node of the given incident edge iterator.
+      Node runningNode(IncEdgeIt) const { return INVALID; }
+      /// \brief The base node of the iterator.
+      ///
+      /// Returns the base node of the given outgoing arc iterator
+      /// (i.e. the source node of the corresponding arc).
+      Node baseNode(OutArcIt) const { return INVALID; }
+      /// \brief The running node of the iterator.
+      ///
+      /// Returns the running node of the given outgoing arc iterator
+      /// (i.e. the target node of the corresponding arc).
+      Node runningNode(OutArcIt) const { return INVALID; }
+      /// \brief The base node of the iterator.
+      ///
+      /// Returns the base node of the given incomming arc iterator
+      /// (i.e. the target node of the corresponding arc).
+      Node baseNode(InArcIt) const { return INVALID; }
+      /// \brief The running node of the iterator.
+      ///
+      /// Returns the running node of the given incomming arc iterator
+      /// (i.e. the source node of the corresponding arc).
+      Node runningNode(InArcIt) const { return INVALID; }
       template <typename _Graph>

lemon/concepts/graph_components.h

-                      r713
+                      r833
 ///\ingroup graph_concepts
 ///\file
 ///\brief The concept of graph components.
+///\brief The concepts of graph components.
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 …
       /// associative containers (e.g. \c std::map).
       ///
       /// \note This operator only have to define some strict ordering of
+      /// \note This operator only has to define some strict ordering of
       /// the items; this order has nothing to do with the iteration
       /// ordering of the items.

lemon/concepts/heap.h

-                      r631
+                      r883
  */
+#ifndef LEMON_CONCEPTS_HEAP_H
+#define LEMON_CONCEPTS_HEAP_H
 ///\ingroup concept
 ///\file
 ///\brief The concept of heaps.
-#ifndef LEMON_CONCEPTS_HEAP_H
-#define LEMON_CONCEPTS_HEAP_H
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
 …
     /// \brief The heap concept.
     ///
+    /// Concept class describing the main interface of heaps. A \e heap
+    /// is a data structure for storing items with specified values called
+    /// \e priorities in such a way that finding the item with minimum
+    /// priority is efficient. In a heap one can change the priority of an
+    /// item, add or erase an item, etc.
+    /// This concept class describes the main interface of heaps.
+    /// The various \ref heaps "heap structures" are efficient
+    /// implementations of the abstract data type \e priority \e queue.
+    /// They store items with specified values called \e priorities
+    /// in such a way that finding and removing the item with minimum
+    /// priority are efficient. The basic operations are adding and
+    /// erasing items, changing the priority of an item, etc.
     ///
+    /// \tparam PR Type of the priority of the items.
+    /// \tparam IM A read and writable item map with int values, used
+    /// Heaps are crucial in several algorithms, such as Dijkstra and Prim.
+    /// Any class that conforms to this concept can be used easily in such
+    /// algorithms.
+    ///
+    /// \tparam PR Type of the priorities of the items.
+    /// \tparam IM A read-writable item map with \c int values, used
     /// internally to handle the cross references.
     /// \tparam Comp A functor class for the ordering of the priorities.
+    /// \tparam CMP A functor class for comparing the priorities.
     /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
     template <typename PR, typename IM, typename Comp = std::less<PR> >
 #else
     template <typename PR, typename IM>
+    template <typename PR, typename IM, typename CMP>
+#else
+    template <typename PR, typename IM, typename CMP = std::less<PR> >
 #endif
     class Heap {
 …
       ///
       /// Each item has a state associated to it. It can be "in heap",
+      /// "pre heap" or "post heap". The later two are indifferent
+      /// from the point of view of the heap, but may be useful for
+      /// the user.
+      /// "pre-heap" or "post-heap". The latter two are indifferent from the
+      /// heap's point of view, but may be useful to the user.
       ///
       /// The item-int map must be initialized in such way that it assigns
 …
       enum State {
         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.
+        PRE_HEAP = -1,  ///< = -1. The "pre-heap" state constant.
+        POST_HEAP = -2  ///< = -2. The "post-heap" state constant.
       };
       /// \brief The constructor.
       ///
       /// The constructor.
+      /// \brief Constructor.
+      ///
+      /// Constructor.
       /// \param map A map that assigns \c int values to keys of type
       /// \c Item. It is used internally by the heap implementations to
       /// handle the cross references. The assigned value must be
+      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
+      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
+#ifdef DOXYGEN
       explicit Heap(ItemIntMap &map) {}
+#else
+      explicit Heap(ItemIntMap&) {}
+#endif
+      /// \brief Constructor.
+      ///
+      /// Constructor.
+      /// \param map A map that assigns \c int values to keys of type
+      /// \c Item. It is used internally by the heap implementations to
+      /// handle the cross references. The assigned value must be
+      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
+      /// \param comp The function object used for comparing the priorities.
+#ifdef DOXYGEN
+      explicit Heap(ItemIntMap &map, const CMP &comp) {}
+#else
+      explicit Heap(ItemIntMap&, const CMP&) {}
+#endif
       /// \brief The number of items stored in the heap.
       ///
       /// Returns the number of items stored in the heap.
+      /// This function returns the number of items stored in the heap.
       int size() const { return 0; }
       /// \brief Checks if the heap is empty.
       ///
       /// Returns \c true if the heap is empty.
+      /// \brief Check if the heap is empty.
+      ///
+      /// This function returns \c true if the heap is empty.
       bool empty() const { return false; }
+      /// \brief Makes the heap empty.
+      ///
+      /// Makes the heap empty.
+      void clear();
+      /// \brief Inserts an item into the heap with the given priority.
+      ///
+      /// Inserts the given item into the heap with the given priority.
+      /// \brief Make the heap empty.
+      ///
+      /// This functon makes the heap empty.
+      /// It does not change the cross reference map. If you want to reuse
+      /// a heap that is not surely empty, you should first clear it and
+      /// then you should set the cross reference map to \c PRE_HEAP
+      /// for each item.
+      void clear() {}
+      /// \brief Insert an item into the heap with the given priority.
+      ///
+      /// This function inserts the given item into the heap with the
+      /// given priority.
       /// \param i The item to insert.
       /// \param p The priority of the item.
+      /// \pre \e i must not be stored in the heap.
+#ifdef DOXYGEN
       void push(const Item &i, const Prio &p) {}
+      /// \brief Returns the item having minimum priority.
+      ///
+      /// Returns the item having minimum priority.
+#else
+      void push(const Item&, const Prio&) {}
+#endif
+      /// \brief Return the item having minimum priority.
+      ///
+      /// This function returns the item having minimum priority.
       /// \pre The heap must be non-empty.
       Item top() const {}
+      Item top() const { return Item(); }
       /// \brief The minimum priority.
       ///
       /// Returns the minimum priority.
+      /// This function returns the minimum priority.
       /// \pre The heap must be non-empty.
       Prio prio() const {}
       /// \brief Removes the item having minimum priority.
       ///
       /// Removes the item having minimum priority.
+      Prio prio() const { return Prio(); }
+      /// \brief Remove the item having minimum priority.
+      ///
+      /// This function removes the item having minimum priority.
       /// \pre The heap must be non-empty.
       void pop() {}
+      /// \brief Removes an item from the heap.
+      ///
+      /// Removes the given item from the heap if it is already stored.
+      /// \brief Remove the given item from the heap.
+      ///
+      /// This function removes the given item from the heap if it is
+      /// already stored.
       /// \param i The item to delete.
+      /// \pre \e i must be in the heap.
+#ifdef DOXYGEN
       void erase(const Item &i) {}
+      /// \brief The priority of an item.
+      ///
+      /// Returns the priority of the given item.
+      /// \param i The item.
+      /// \pre \c i must be in the heap.
+#else
+      void erase(const Item&) {}
+#endif
+      /// \brief The priority of the given item.
+      ///
+      /// This function returns the priority of the given item.
+      /// \param i The item.
+      /// \pre \e i must be in the heap.
+#ifdef DOXYGEN
       Prio operator[](const Item &i) const {}
+      /// \brief Sets the priority of an item or inserts it, if it is
+#else
+      Prio operator[](const Item&) const { return Prio(); }
+#endif
+      /// \brief Set the priority of an item or insert it, if it is
       /// not stored in the heap.
       ///
       /// This method sets the priority of the given item if it is
       /// already stored in the heap.
       /// Otherwise it inserts the given item with the given priority.
+      /// already stored in the heap. Otherwise it inserts the given
+      /// item into the heap with the given priority.
       ///
       /// \param i The item.
       /// \param p The priority.
+#ifdef DOXYGEN
       void set(const Item &i, const Prio &p) {}
+      /// \brief Decreases the priority of an item to the given value.
+      ///
+      /// Decreases the priority of an item to the given value.
+#else
+      void set(const Item&, const Prio&) {}
+#endif
+      /// \brief Decrease the priority of an item to the given value.
+      ///
+      /// This function decreases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
+      /// \pre \c i must be stored in the heap with priority at least \c p.
+      /// \pre \e i must be stored in the heap with priority at least \e p.
+#ifdef DOXYGEN
       void decrease(const Item &i, const Prio &p) {}
+      /// \brief Increases the priority of an item to the given value.
+      ///
+      /// Increases the priority of an item to the given value.
+#else
+      void decrease(const Item&, const Prio&) {}
+#endif
+      /// \brief Increase the priority of an item to the given value.
+      ///
+      /// This function increases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
+      /// \pre \c i must be stored in the heap with priority at most \c p.
+      /// \pre \e i must be stored in the heap with priority at most \e p.
+#ifdef DOXYGEN
       void increase(const Item &i, const Prio &p) {}
+      /// \brief Returns if an item is in, has already been in, or has
+      /// never been in the heap.
+#else
+      void increase(const Item&, const Prio&) {}
+#endif
+      /// \brief Return the state of an item.
       ///
       /// This method returns \c PRE_HEAP if the given item has never
 …
       /// to the heap again.
       /// \param i The item.
+#ifdef DOXYGEN
       State state(const Item &i) const {}
+      /// \brief Sets the state of an item in the heap.
+      ///
+      /// Sets the state of the given item in the heap. It can be used
+      /// to manually clear the heap when it is important to achive the
+      /// better time complexity.
+#else
+      State state(const Item&) const { return PRE_HEAP; }
+#endif
+      /// \brief Set the state of an item in the heap.
+      ///
+      /// This function sets the state of the given item in the heap.
+      /// It can be used to manually clear the heap when it is important
+      /// to achive better time complexity.
       /// \param i The item.
       /// \param st The state. It should not be \c IN_HEAP.
+#ifdef DOXYGEN
       void state(const Item& i, State st) {}
+#else
+      void state(const Item&, State) {}
+#endif

lemon/concepts/path.h

-                      r606
+                      r832
 ///\ingroup concept
 ///\file
 ///\brief Classes for representing paths in digraphs.
+///\brief The concept of paths
 ///
 …
     /// A skeleton structure for representing directed paths in a
     /// digraph.
+    /// In a sense, a path can be treated as a list of arcs.
+    /// LEMON path types just store this list. As a consequence, they cannot
+    /// enumerate the nodes on the path directly and a zero length path
+    /// cannot store its source node.
+    ///
+    /// The arcs of a path should be stored in the order of their directions,
+    /// i.e. the target node of each arc should be the same as the source
+    /// node of the next arc. This consistency could be checked using
+    /// \ref checkPath().
+    /// The source and target nodes of a (consistent) path can be obtained
+    /// using \ref pathSource() and \ref pathTarget().
+    ///
+    /// A path can be constructed from another path of any type using the
+    /// copy constructor or the assignment operator.
+    ///
     /// \tparam GR The digraph type in which the path is.
-    ///
-    /// In a sense, the path can be treated as a list of arcs. The
-    /// lemon path type stores just this list. As a consequence it
-    /// cannot enumerate the nodes in the path and the zero length
-    /// paths cannot store the source.
-    ///
     template <typename GR>
     class Path {
 …
       Path() {}
       /// \brief Template constructor
+      /// \brief Template copy constructor
       template <typename CPath>
       Path(const CPath& cpath) {}
       /// \brief Template assigment
+      /// \brief Template assigment operator
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
 …
+      }
       /// Length of the path ie. the number of arcs in the path.
+      /// Length of the path, i.e. the number of arcs on the path.
       int length() const { return 0;}
 …
       void clear() {}
       /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path.
       ///
       /// This class is used to iterate on the arcs of the paths.
+      /// LEMON style iterator class for enumerating the arcs of a path.
       class ArcIt {
       public:
 …
         /// Invalid constructor
         ArcIt(Invalid) {}
         /// Constructor for first arc
+        /// Sets the iterator to the first arc of the given path
         ArcIt(const Path &) {}
         /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 …
     ///
     /// A skeleton structure for path dumpers. The path dumpers are
+    /// the generalization of the paths. The path dumpers can
+    /// enumerate the arcs of the path wheter in forward or in
+    /// backward order.  In most time these classes are not used
+    /// directly rather it used to assign a dumped class to a real
+    /// path type.
+    /// the generalization of the paths, they can enumerate the arcs
+    /// of the path either in forward or in backward order.
+    /// These classes are typically not used directly, they are rather
+    /// used to be assigned to a real path type.
     ///
     /// The main purpose of this concept is that the shortest path
+    /// algorithms can enumerate easily the arcs in reverse order.
+    /// If we would like to give back a real path from these
+    /// algorithms then we should create a temporarly path object. In
+    /// LEMON such algorithms gives back a path dumper what can
+    /// assigned to a real path and the dumpers can be implemented as
+    /// algorithms can enumerate the arcs easily in reverse order.
+    /// In LEMON, such algorithms give back a (reverse) path dumper that
+    /// can be assigned to a real path. The dumpers can be implemented as
     /// an adaptor class to the predecessor map.
     ///
     /// \tparam GR The digraph type in which the path is.
-    ///
-    /// The paths can be constructed from any path type by a
-    /// template constructor or a template assignment operator.
     template <typename GR>
     class PathDumper {
 …
       typedef typename Digraph::Arc Arc;
       /// Length of the path ie. the number of arcs in the path.
+      /// Length of the path, i.e. the number of arcs on the path.
       int length() const { return 0;}
 …
       /// \brief Forward or reverse dumping
       ///
+      /// If the RevPathTag is defined and true then reverse dumping
+      /// is provided in the path dumper. In this case instead of the
+      /// ArcIt the RevArcIt iterator should be implemented in the
+      /// dumper.
+      /// If this tag is defined to be \c True, then reverse dumping
+      /// is provided in the path dumper. In this case, \c RevArcIt
+      /// iterator should be implemented instead of \c ArcIt iterator.
       typedef False RevPathTag;
       /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path.
       ///
       /// This class is used to iterate on the arcs of the paths.
+      /// LEMON style iterator class for enumerating the arcs of a path.
       class ArcIt {
       public:
 …
         /// Invalid constructor
         ArcIt(Invalid) {}
         /// Constructor for first arc
+        /// Sets the iterator to the first arc of the given path
         ArcIt(const PathDumper&) {}
         /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 …
       };
+      /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path
+      /// in reverse direction.
       ///
       /// This class is used to iterate on the arcs of the paths in
       /// reverse direction.
+      /// LEMON style iterator class for enumerating the arcs of a path
+      /// in reverse direction.
       class RevArcIt {
       public:
 …
         /// Invalid constructor
         RevArcIt(Invalid) {}
         /// Constructor for first arc
+        /// Sets the iterator to the last arc of the given path
         RevArcIt(const PathDumper &) {}
         /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }

lemon/counter.h

r463	r833
213	213	/// 'Do nothing' version of Counter.
214	214
215		/// This class can be used in the same way as \ref Counter ~~however~~ it
	215	/// This class can be used in the same way as \ref Counter, but it
216	216	/// does not count at all and does not print report on destruction.
217	217	///

lemon/cplex.cc

-                      r623
+                      r793
+  }
+  int CplexBase::_addRow(Value lb, ExprIterator b,
+                         ExprIterator e, Value ub) {
+    int i = CPXgetnumrows(cplexEnv(), _prob);
+    if (lb == -INF) {
+      const char s = 'L';
+      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
+    } else if (ub == INF) {
+      const char s = 'G';
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
+    } else if (lb == ub){
+      const char s = 'E';
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
+    } else {
+      const char s = 'R';
+      double len = ub - lb;
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
+    }
+    std::vector<int> indices;
+    std::vector<int> rowlist;
+    std::vector<Value> values;
+    for(ExprIterator it=b; it!=e; ++it) {
+      indices.push_back(it->first);
+      values.push_back(it->second);
+      rowlist.push_back(i);
+    }
+    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
+                   &rowlist.front(), &indices.front(), &values.front());
+    return i;
+  }
   void CplexBase::_eraseCol(int i) {

lemon/cplex.h

r623	r793
94	94	virtual int _addCol();
95	95	virtual int _addRow();
	96	virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
96	97
97	98	virtual void _eraseCol(int i);

lemon/dfs.h

-                      r631
+                      r891
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
 …
     ///The type of the map that indicates which nodes are processed.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
 …
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
+  ///\tparam TR The traits class that defines various types used by the
+  ///algorithm. By default, it is \ref DfsDefaultTraits
+  ///"DfsDefaultTraits<GR>".
+  ///In most cases, this parameter should not be set directly,
+  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
 …
     ///The simplest way to execute the DFS algorithm is to use one of the
     ///member functions called \ref run(Node) "run()".\n
     ///If you need more control on the execution, first you have to call
     ///\ref init(), then you can add a source node with \ref addSource()
+    ///If you need better control on the execution, you have to call
+    ///\ref init() first, then you can add a source node with \ref addSource()
     ///and perform the actual computation with \ref start().
     ///This procedure can be repeated if there are nodes that have not
 …
     ///Runs the algorithm to visit all nodes in the digraph.
+    ///This method runs the %DFS algorithm in order to compute the
+    ///%DFS path to each node.
+    ///
+    ///The algorithm computes
+    ///- the %DFS tree (forest),
+    ///- the distance of each node from the root(s) in the %DFS tree.
+    ///This method runs the %DFS algorithm in order to visit all nodes
+    ///in the digraph.
     ///
     ///\note <tt>d.run()</tt> is just a shortcut of the following code.
 …
     ///@{
     ///The DFS path to a node.
     ///Returns the DFS path to a node.
+    ///The DFS path to the given node.
+    ///Returns the DFS path to the given node from the root(s).
     ///
     ///\warning \c t should be reached from the root(s).
 …
     Path path(Node t) const { return Path(*G, *_pred, t); }
     ///The distance of a node from the root(s).
     ///Returns the distance of a node from the root(s).
+    ///The distance of the given node from the root(s).
+    ///Returns the distance of the given node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
 …
     int dist(Node v) const { return (*_dist)[v]; }
     ///Returns the 'previous arc' of the %DFS tree for a node.
+    ///Returns the 'previous arc' of the %DFS tree for the given node.
     ///This function returns the 'previous arc' of the %DFS tree for the
 …
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
     ///\ref predNode().
+    ///\ref predNode() and \ref predMap().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     Arc predArc(Node v) const { return (*_pred)[v];}
     ///Returns the 'previous node' of the %DFS tree.
+    ///Returns the 'previous node' of the %DFS tree for the given node.
     ///This function returns the 'previous node' of the %DFS
     ///tree for the node \c v, i.e. it returns the last but one node
     ///from a %DFS path from a root to \c v. It is \c INVALID
+    ///of a %DFS path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
     ///\ref predArc().
+    ///\ref predArc() and \ref predMap().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     ///
     ///Returns a const reference to the node map that stores the predecessor
     ///arcs, which form the DFS tree.
+    ///arcs, which form the DFS tree (forest).
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     const PredMap &predMap() const { return *_pred;}
     ///Checks if a node is reached from the root(s).
+    ///Checks if the given node. node is reached from the root(s).
     ///Returns \c true if \c v is reached from the root(s).
 …
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 …
     ///The type of the map that indicates which nodes are reached.
     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
 …
     ///The type of the DFS paths.
     ///It must meet the \ref concepts::Path "Path" concept.
+    ///It must conform to the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
 …
   /// Default traits class used by DfsWizard
+  /// To make it easier to use Dfs algorithm
+  /// we have created a wizard class.
+  /// This \ref DfsWizard class needs default traits,
+  /// as well as the \ref Dfs class.
+  /// The \ref DfsWizardBase is a class to be the default traits of the
+  /// \ref DfsWizard class.
+  /// Default traits class used by DfsWizard.
+  /// \tparam GR The type of the digraph.
   template<class GR>
   class DfsWizardBase : public DfsWizardDefaultTraits<GR>
 …
     /// Constructor.
     /// This constructor does not require parameters, therefore it initiates
+    /// This constructor does not require parameters, it initiates
     /// all of the attributes to \c 0.
     DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
 …
   /// This class should only be used through the \ref dfs() function,
   /// which makes it easier to use the algorithm.
+  ///
+  /// \tparam TR The traits class that defines various types used by the
+  /// algorithm.
   template<class TR>
   class DfsWizard : public TR
 …
     typedef TR Base;
-    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 …
     typedef typename Digraph::OutArcIt OutArcIt;
-    ///\brief The type of the map that stores the predecessor
-    ///arcs of the DFS paths.
     typedef typename TR::PredMap PredMap;
-    ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
-    ///\brief The type of the map that indicates which nodes are reached.
     typedef typename TR::ReachedMap ReachedMap;
-    ///\brief The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
-    ///The type of the DFS paths
     typedef typename TR::Path Path;
 …
     ///Runs DFS algorithm to visit all nodes in the digraph.
     ///This method runs DFS algorithm in order to compute
     ///the DFS path to each node.
+    ///This method runs DFS algorithm in order to visit all nodes
+    ///in the digraph.
     void run()
+    {
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the predecessor map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that stores the predecessor arcs of the nodes.
     template<class T>
     DfsWizard<SetPredMapBase<T> > predMap(const T &t)
 …
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the reached map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that indicates which nodes are reached.
     template<class T>
     DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the distance map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that stores the distances of the nodes calculated
+    ///by the algorithm.
     template<class T>
     DfsWizard<SetDistMapBase<T> > distMap(const T &t)
 …
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///\brief \ref named-func-param "Named parameter" for setting
+    ///the processed map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that indicates which nodes are processed.
     template<class T>
     DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
 …
     ///
     /// The type of the map that indicates which nodes are reached.
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 …
   /// does not observe the DFS events. If you want to observe the DFS
   /// events, you should implement your own visitor class.
   /// \tparam TR Traits class to set various data types used by the
   /// algorithm. The default traits class is
   /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
   /// See \ref DfsVisitDefaultTraits for the documentation of
   /// a DFS visit traits class.
+  /// \tparam TR The traits class that defines various types used by the
+  /// algorithm. By default, it is \ref DfsVisitDefaultTraits
+  /// "DfsVisitDefaultTraits<GR>".
+  /// In most cases, this parameter should not be set directly,
+  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
 …
     /// The simplest way to execute the DFS algorithm is to use one of the
     /// member functions called \ref run(Node) "run()".\n
     /// If you need more control on the execution, first you have to call
     /// \ref init(), then you can add a source node with \ref addSource()
+    /// If you need better control on the execution, you have to call
+    /// \ref init() first, then you can add a source node with \ref addSource()
     /// and perform the actual computation with \ref start().
     /// This procedure can be repeated if there are nodes that have not
 …
     /// \brief Runs the algorithm to visit all nodes in the digraph.
+    /// This method runs the %DFS algorithm in order to
+    /// compute the %DFS path to each node.
+    ///
+    /// The algorithm computes
+    /// - the %DFS tree (forest),
+    /// - the distance of each node from the root(s) in the %DFS tree.
+    /// This method runs the %DFS algorithm in order to visit all nodes
+    /// in the digraph.
     ///
     /// \note <tt>d.run()</tt> is just a shortcut of the following code.
 …
     ///@{
     /// \brief Checks if a node is reached from the root(s).
+    /// \brief Checks if the given node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).

lemon/dijkstra.h

-                      r631
+                      r891
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
     ///The type of the length of the arcs.
+    ///The type of the arc lengths.
     typedef typename LEN::Value Value;
 …
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a \c DistMap.
 …
   /// \ingroup shortest_path
   ///This class provides an efficient implementation of the %Dijkstra algorithm.
+  ///
+  ///The %Dijkstra algorithm solves the single-source shortest path problem
+  ///when all arc lengths are non-negative. If there are negative lengths,
+  ///the BellmanFord algorithm should be used instead.
   ///
   ///The arc lengths are passed to the algorithm using a
 …
   ///it is necessary. The default map type is \ref
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
+  ///\tparam TR The traits class that defines various types used by the
+  ///algorithm. By default, it is \ref DijkstraDefaultTraits
+  ///"DijkstraDefaultTraits<GR, LEN>".
+  ///In most cases, this parameter should not be set directly,
+  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename LEN, typename TR>
 …
     typedef typename TR::Digraph Digraph;
     ///The type of the length of the arcs.
     typedef typename TR::LengthMap::Value Value;
+    ///The type of the arc lengths.
+    typedef typename TR::Value Value;
     ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap
 …
     ///passed to the constructor of the cross reference and the cross
     ///reference should be passed to the constructor of the heap).
     ///However external heap and cross reference objects could also be
+    ///However, external heap and cross reference objects could also be
     ///passed to the algorithm using the \ref heap() function before
     ///calling \ref run(Node) "run()" or \ref init().
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c OperationTraits type.
+    /// For more information, see \ref DijkstraDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
 …
     ///The simplest way to execute the %Dijkstra algorithm is to use
     ///one of the member functions called \ref run(Node) "run()".\n
     ///If you need more control on the execution, first you have to call
     ///\ref init(), then you can add several source nodes with
+    ///If you need better control on the execution, you have to call
+    ///\ref init() first, then you can add several source nodes with
     ///\ref addSource(). Finally the actual path computation can be
     ///performed with one of the \ref start() functions.
 …
     ///The results of the %Dijkstra algorithm can be obtained using these
     ///functions.\n
     ///Either \ref run(Node) "run()" or \ref start() should be called
+    ///Either \ref run(Node) "run()" or \ref init() should be called
     ///before using them.
     ///@{
     ///The shortest path to a node.
     ///Returns the shortest path to a node.
+    ///The shortest path to the given node.
+    ///Returns the shortest path to the given node from the root(s).
     ///
     ///\warning \c t should be reached from the root(s).
 …
     Path path(Node t) const { return Path(*G, *_pred, t); }
     ///The distance of a node from the root(s).
     ///Returns the distance of a node from the root(s).
+    ///The distance of the given node from the root(s).
+    ///Returns the distance of the given node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
 …
     Value dist(Node v) const { return (*_dist)[v]; }
+    ///Returns the 'previous arc' of the shortest path tree for a node.
+    ///\brief Returns the 'previous arc' of the shortest path tree for
+    ///the given node.
+    ///
     ///This function returns the 'previous arc' of the shortest path
     ///tree for the node \c v, i.e. it returns the last arc of a
 …
     ///
     ///The shortest path tree used here is equal to the shortest path
     ///tree used in \ref predNode().
+    ///tree used in \ref predNode() and \ref predMap().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     Arc predArc(Node v) const { return (*_pred)[v]; }
+    ///Returns the 'previous node' of the shortest path tree for a node.
+    ///\brief Returns the 'previous node' of the shortest path tree for
+    ///the given node.
+    ///
     ///This function returns the 'previous node' of the shortest path
     ///tree for the node \c v, i.e. it returns the last but one node
     ///from a shortest path from a root to \c v. It is \c INVALID
+    ///of a shortest path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The shortest path tree used here is equal to the shortest path
     ///tree used in \ref predArc().
+    ///tree used in \ref predArc() and \ref predMap().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     ///
     ///Returns a const reference to the node map that stores the predecessor
     ///arcs, which form the shortest path tree.
+    ///arcs, which form the shortest path tree (forest).
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
 …
     const PredMap &predMap() const { return *_pred;}
     ///Checks if a node is reached from the root(s).
+    ///Checks if the given node is reached from the root(s).
     ///Returns \c true if \c v is reached from the root(s).
 …
                                           Heap::POST_HEAP; }
     ///The current distance of a node from the root(s).
     ///Returns the current distance of a node from the root(s).
+    ///The current distance of the given node from the root(s).
+    ///Returns the current distance of the given node from the root(s).
     ///It may be decreased in the following processes.
     ///
 …
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
     ///The type of the length of the arcs.
+    ///The type of the arc lengths.
     typedef typename LEN::Value Value;
 …
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 …
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a DistMap.
 …
     ///The type of the shortest paths.
     ///It must meet the \ref concepts::Path "Path" concept.
+    ///It must conform to the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
 …
   /// Default traits class used by DijkstraWizard
+  /// To make it easier to use Dijkstra algorithm
+  /// we have created a wizard class.
+  /// This \ref DijkstraWizard class needs default traits,
+  /// as well as the \ref Dijkstra class.
+  /// The \ref DijkstraWizardBase is a class to be the default traits of the
+  /// \ref DijkstraWizard class.
+  /// Default traits class used by DijkstraWizard.
+  /// \tparam GR The type of the digraph.
+  /// \tparam LEN The type of the length map.
   template<typename GR, typename LEN>
   class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
 …
   /// This class should only be used through the \ref dijkstra() function,
   /// which makes it easier to use the algorithm.
+  ///
+  /// \tparam TR The traits class that defines various types used by the
+  /// algorithm.
   template<class TR>
   class DijkstraWizard : public TR
 …
     typedef TR Base;
-    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 …
     typedef typename Digraph::OutArcIt OutArcIt;
-    ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
-    ///The type of the length of the arcs.
     typedef typename LengthMap::Value Value;
-    ///\brief The type of the map that stores the predecessor
-    ///arcs of the shortest paths.
     typedef typename TR::PredMap PredMap;
-    ///The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
-    ///The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
-    ///The type of the shortest paths
     typedef typename TR::Path Path;
-    ///The heap type used by the dijkstra algorithm.
     typedef typename TR::Heap Heap;
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the predecessor map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that stores the predecessor arcs of the nodes.
     template<class T>
     DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///\brief \ref named-templ-param "Named parameter" for setting
+    ///the distance map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that stores the distances of the nodes calculated
+    ///by the algorithm.
     template<class T>
     DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
 …
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///\brief \ref named-func-param "Named parameter" for setting
+    ///the processed map.
+    ///
+    ///\ref named-templ-param "Named parameter" function for setting
+    ///the map that indicates which nodes are processed.
     template<class T>
     DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
 …
       SetPathBase(const TR &b) : TR(b) {}
     };
     ///\brief \ref named-func-param "Named parameter"
     ///for getting the shortest path to the target node.

lemon/dim2.h

-                      r463
+                      r761
 #include <iostream>
 ///\ingroup misc
+///\ingroup geomdat
 ///\file
 ///\brief A simple two dimensional vector and a bounding box implementation
-///
-/// The class \ref lemon::dim2::Point "dim2::Point" implements
-/// a two dimensional vector with the usual operations.
-///
-/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
-/// the rectangular bounding box of a set of
-/// \ref lemon::dim2::Point "dim2::Point"'s.
 namespace lemon {
 …
   namespace dim2 {
   /// \addtogroup misc
+  /// \addtogroup geomdat
   /// @{

lemon/edge_set.h

-                      r717
+                      r834
   /// all arcs incident to the given node is erased from the arc set.
   ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
+  /// It provides only linear time counting for nodes and arcs.
+  ///
   /// \param GR The type of the graph which shares its node set with
   /// this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
   /// concept.
-  ///
-  /// This class fully conforms to the \ref concepts::Digraph
-  /// "Digraph" concept.
   template <typename GR>
   class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
 …
   /// incident to the given node is erased from the arc set.
   ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph"
+  /// concept.
+  /// It provides only linear time counting for nodes, edges and arcs.
+  ///
   /// \param GR The type of the graph which shares its node set
   /// with this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
-  /// concept.
-  ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
   /// concept.
   template <typename GR>
 …
+    }

Context Navigation

Changes in / [900:5100072d83ca:902:d2bc45e8f6f2] in lemon

Legend:

CMakeLists.txt

INSTALL

Makefile.am

configure.ac

doc/CMakeLists.txt

doc/Doxyfile.in

doc/Makefile.am

doc/groups.dox

doc/mainpage.dox

doc/min_cost_flow.dox

lemon/Makefile.am

lemon/adaptors.h

lemon/bfs.h

lemon/bin_heap.h

lemon/bits/edge_set_extender.h

lemon/bits/graph_extender.h

lemon/bucket_heap.h

lemon/cbc.cc

lemon/cbc.h

lemon/circulation.h

lemon/clp.cc

lemon/clp.h

lemon/concepts/digraph.h

lemon/concepts/graph.h

lemon/concepts/graph_components.h

lemon/concepts/heap.h

lemon/concepts/path.h

lemon/counter.h

lemon/cplex.cc

lemon/cplex.h

lemon/dfs.h

lemon/dijkstra.h

lemon/dim2.h

lemon/edge_set.h