Changes in / [827:580af8cf2f6a:826:c160bf9f18ef] in lemon

Files:

• CMakeLists.txt (modified) (1 diff)
• Makefile.am (modified) (1 diff)
• configure.ac (modified) (1 diff)
• doc/CMakeLists.txt (modified) (2 diffs)
• doc/Doxyfile.in (modified) (4 diffs)
• doc/Makefile.am (modified) (1 diff)
• doc/groups.dox (modified) (18 diffs)
• doc/mainpage.dox (modified) (2 diffs)
• doc/min_cost_flow.dox (modified) (1 diff)
• doc/references.bib (deleted)
• lemon/Makefile.am (modified) (4 diffs)
• lemon/bellman_ford.h (deleted)
• lemon/bfs.h (modified) (32 diffs)
• lemon/bin_heap.h (modified) (14 diffs)
• lemon/binom_heap.h (deleted)
• lemon/bits/map_extender.h (modified) (2 diffs)
• lemon/bucket_heap.h (modified) (27 diffs)
• lemon/cbc.cc (modified) (1 diff)
• lemon/cbc.h (modified) (1 diff)
• lemon/circulation.h (modified) (4 diffs)
• lemon/clp.cc (modified) (1 diff)
• lemon/clp.h (modified) (1 diff)
• lemon/concepts/digraph.h (modified) (15 diffs)
• lemon/concepts/graph.h (modified) (26 diffs)
• lemon/concepts/graph_components.h (modified) (1 diff)
• lemon/concepts/heap.h (modified) (7 diffs)
• lemon/concepts/maps.h (modified) (1 diff)
• lemon/cplex.cc (modified) (1 diff)
• lemon/cplex.h (modified) (1 diff)
• lemon/dfs.h (modified) (32 diffs)
• lemon/dijkstra.h (modified) (31 diffs)
• lemon/dim2.h (modified) (2 diffs)
• lemon/fib_heap.h (modified) (12 diffs)
• lemon/fourary_heap.h (deleted)
• lemon/full_graph.h (modified) (13 diffs)
• lemon/glpk.cc (modified) (1 diff)
• lemon/glpk.h (modified) (1 diff)
• lemon/gomory_hu.h (modified) (2 diffs)
• lemon/grid_graph.h (modified) (16 diffs)
• lemon/hartmann_orlin.h (deleted)
• lemon/howard.h (deleted)
• lemon/hypercube_graph.h (modified) (4 diffs)
• lemon/karp.h (deleted)
• lemon/kary_heap.h (deleted)
• lemon/list_graph.h (modified) (28 diffs)
• lemon/lp_base.h (modified) (3 diffs)
• lemon/lp_skeleton.cc (modified) (1 diff)
• lemon/lp_skeleton.h (modified) (1 diff)
• lemon/maps.h (modified) (32 diffs)
• lemon/min_cost_arborescence.h (modified) (1 diff)
• lemon/network_simplex.h (modified) (14 diffs)
• lemon/pairing_heap.h (deleted)
• lemon/path.h (modified) (1 diff)
• lemon/preflow.h (modified) (6 diffs)
• lemon/radix_heap.h (modified) (9 diffs)
• lemon/smart_graph.h (modified) (12 diffs)
• lemon/soplex.cc (modified) (1 diff)
• lemon/soplex.h (modified) (1 diff)
• m4/lx_check_coin.m4 (modified) (1 diff)
• scripts/bib2dox.py (deleted)
• scripts/bootstrap.sh (deleted)
• scripts/chg-len.py (modified) (1 diff)
• scripts/mk-release.sh (modified) (1 diff)
• scripts/unify-sources.sh (modified) (1 diff)
• test/CMakeLists.txt (modified) (2 diffs)
• test/Makefile.am (modified) (4 diffs)
• test/bellman_ford_test.cc (deleted)
• test/circulation_test.cc (modified) (1 diff)
• test/digraph_test.cc (modified) (3 diffs)
• test/graph_test.cc (modified) (5 diffs)
• test/heap_test.cc (modified) (13 diffs)
• test/maps_test.cc (modified) (6 diffs)
• test/min_mean_cycle_test.cc (deleted)
• test/mip_test.cc (modified) (1 diff)
• test/preflow_test.cc (modified) (1 diff)
• test/test_tools.h (modified) (1 diff)
• tools/lemon-0.x-to-1.x.sh (modified) (2 diffs)

CMakeLists.txt

@@ -35 +35 @@
 CHECK_TYPE_SIZE("long long" LONG_LONG)
 SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
-
-INCLUDE(FindPythonInterp)
 
 ENABLE_TESTING()

Makefile.am

@@ -18 +18 @@
         cmake/FindGLPK.cmake \
         cmake/FindCOIN.cmake \
-        cmake/LEMONConfig.cmake.in \
         cmake/version.cmake.in \
         cmake/version.cmake \

configure.ac

@@ -42 +42 @@
 
 AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
-AC_CHECK_PROG([python_found],[python],[yes],[no])
 AC_CHECK_PROG([gs_found],[gs],[yes],[no])
 

doc/CMakeLists.txt

@@ -10 +10 @@
 )
 
-IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
+IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
   FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
   SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha)
@@ -29 +29 @@
     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

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

doc/Makefile.am

@@ -67 +67 @@
         fi
 
-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
+html-local: $(DOC_PNG_IMAGES)
         if test ${doxygen_found} = yes; then \
           cd doc; \

doc/groups.dox

@@ -227 +227 @@
 
 /**
+@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
@@ -239 +247 @@
 any kind of path structure.
 
-\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.
+\sa lemon::concepts::Path
 */
 
@@ -281 +260 @@
 
 /**
-@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
@@ -317 +274 @@
 
 This group contains the common graph search algorithms, namely
-\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
-\ref clrs01algorithms.
+\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
 */
 
@@ -326 +282 @@
 \brief Algorithms for finding shortest paths.
 
-This group contains the algorithms for finding shortest paths in digraphs
-\ref clrs01algorithms.
+This group contains the algorithms for finding shortest paths in digraphs.
 
  - \ref Dijkstra algorithm for finding shortest paths from a source node
@@ -344 +299 @@
 
 /**
-@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
@@ -358 +304 @@
 
 This group contains the algorithms for finding maximum flows and
-feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
+feasible circulations.
 
 The \e maximum \e flow \e problem is to find a flow of maximum value between
@@ -373 +319 @@
 
 LEMON contains several algorithms for solving maximum flow problems:
-- \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
+- \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
 fastest method for computing a maximum flow. All implementations
 also provide functions to query the minimum cut, which is the dual
@@ -400 +342 @@
 
 This group contains the algorithms for finding minimum cost flows and
-circulations \ref amo93networkflows. For more information about this
-problem and its dual solution, see \ref min_cost_flow
-"Minimum Cost Flow Problem".
+circulations. 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 dantzig63linearprog, \ref kellyoneill91netsimplex.
+   pivot strategies.
  - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
-   cost scaling \ref goldberg90approximation, \ref goldberg97efficient,
-   \ref bunnagel98efficient.
+   cost scaling.
  - \ref CapacityScaling Successive Shortest %Path algorithm with optional
-   capacity scaling \ref edmondskarp72theoretical.
- - \ref CancelAndTighten The Cancel and Tighten algorithm
-   \ref goldberg89cyclecanceling.
- - \ref CycleCanceling Cycle-Canceling algorithms
-   \ref klein67primal, \ref goldberg89cyclecanceling.
+   capacity scaling.
+ - \ref CancelAndTighten The Cancel and Tighten algorithm.
+ - \ref CycleCanceling Cycle-Canceling algorithms.
 
 In general NetworkSimplex is the most efficient implementation,
@@ -438 +376 @@
 
 \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:
@@ -454 +392 @@
 
 /**
-@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 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
 */
 
@@ -531 +456 @@
 
 /**
-@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 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 auxalg Auxiliary Algorithms
+@ingroup algs
+\brief Auxiliary algorithms implemented in LEMON.
+
+This group contains some algorithms implemented in LEMON
+in order to make it easier to implement complex algorithms.
 */
 
@@ -561 +480 @@
 This group contains the approximation and heuristic algorithms
 implemented in LEMON.
-*/
-
-/**
-@defgroup auxalg Auxiliary Algorithms
-@ingroup algs
-\brief Auxiliary algorithms implemented in LEMON.
-
-This group contains some algorithms implemented in LEMON
-in order to make it easier to implement complex algorithms.
 */
 
@@ -582 +492 @@
 
 /**
-@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.
-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.
+\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.
 */
 
@@ -681 +588 @@
 
 /**
-@defgroup dimacs_group DIMACS Format
+@defgroup dimacs_group DIMACS format
 @ingroup io_group
 \brief Read and write files in DIMACS format
@@ -730 +637 @@
 \brief Skeleton and concept checking classes for graph structures
 
-This group contains the skeletons and concept checking classes of
-graph structures.
+This group contains the skeletons and concept checking classes of LEMON's
+graph structures and helper classes used to implement these.
 */
 
@@ -743 +650 @@
 
 /**
+\anchor demoprograms
+
+@defgroup demos Demo Programs
+
+Some demo programs are listed here. Their full source codes can be found in
+the \c demo subdirectory of the source tree.
+
+In order to compile them, use the <tt>make demo</tt> or the
+<tt>make check</tt> commands.
+*/
+
+/**
 @defgroup tools Standalone Utility Applications
 
@@ -751 +670 @@
 */
 
-/**
-\anchor demoprograms
-
-@defgroup demos Demo Programs
-
-Some demo programs are listed here. Their full source codes can be found in
-the \c demo subdirectory of the source tree.
-
-In order to compile them, use the <tt>make demo</tt> or the
-<tt>make check</tt> commands.
-*/
-
 }

doc/mainpage.dox

@@ -22 +22 @@
 \section intro Introduction
 
-<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.
+\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>
@@ -36 +39 @@
 </b>
 
-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
+\subsection howtoread How to read the documentation
 
 If you would like to get to know the library, see

doc/min_cost_flow.dox

@@ -27 +27 @@
 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 \ref amo93networkflows.
+and arc costs.
 
 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,

lemon/Makefile.am

@@ -58 +58 @@
         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/cbc.h \
@@ -81 +79 @@
         lemon/euler.h \
         lemon/fib_heap.h \
-        lemon/fourary_heap.h \
         lemon/full_graph.h \
         lemon/glpk.h \
@@ -87 +84 @@
         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 \
@@ -106 +99 @@
         lemon/nauty_reader.h \
         lemon/network_simplex.h \
-        lemon/pairing_heap.h \
         lemon/path.h \
         lemon/preflow.h \

lemon/bfs.h

@@ -48 +48 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -63 +63 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -83 +82 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -98 +97 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
@@ -227 +226 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
@@ -247 +246 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
@@ -267 +266 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
@@ -287 +286 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
@@ -415 +414 @@
     ///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 better control on the execution, you have to call
-    ///\ref init() first, then you can add several source nodes with
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), 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.
@@ -739 +738 @@
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns the shortest path to the given node from the root(s).
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -749 +748 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -760 +759 @@
     int dist(Node v) const { return (*_dist)[v]; }
 
-    ///\brief Returns the 'previous arc' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous arc' of the shortest path tree for a 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
@@ -769 +767 @@
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predNode() and \ref predMap().
+    ///tree used in \ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -775 +773 @@
     Arc predArc(Node v) const { return (*_pred)[v];}
 
-    ///\brief Returns the 'previous node' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous node' of the shortest path tree for a 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
-    ///of a shortest path from a root to \c v. It is \c INVALID
+    ///from 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() and \ref predMap().
+    ///tree used in \ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -805 +802 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
+    ///arcs, which form the shortest path tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -811 +808 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -837 +834 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -852 +849 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
@@ -872 +869 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -887 +884 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
@@ -902 +899 @@
 
     ///The type of the shortest paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -908 +905 @@
   /// Default traits class used by BfsWizard
 
-  /// Default traits class used by BfsWizard.
-  /// \tparam GR The type of the digraph.
+  /// 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.
   template<class GR>
   class BfsWizardBase : public BfsWizardDefaultTraits<GR>
@@ -937 +938 @@
     /// Constructor.
 
-    /// This constructor does not require parameters, it initiates
+    /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to \c 0.
     BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -967 +968 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -974 +976 @@
     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;
 
@@ -1060 +1068 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     BfsWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1079 +1086 @@
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
     template<class T>
     BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
@@ -1098 +1104 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     BfsWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1118 +1122 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1262 +1265 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1423 +1426 @@
     /// 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 better control on the execution, you have to call
-    /// \ref init() first, then you can add several source nodes with
+    /// If you need more control on the execution, first you have to call
+    /// \ref init(), 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.
@@ -1733 +1736 @@
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
+    /// \brief Checks if a node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).

lemon/bin_heap.h

@@ -20 +20 @@
 #define LEMON_BIN_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Binary heap implementation.
+///\brief Binary Heap implementation.
 
 #include <vector>
@@ -30 +30 @@
 namespace lemon {
 
-  /// \ingroup heaps
-  ///
-  /// \brief Binary heap data structure.
-  ///
-  /// This class implements the \e binary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// \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
+  ///\ingroup auxdat
+  ///
+  ///\brief A Binary Heap implementation.
+  ///
+  ///This class implements the \e binary \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. \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
   template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
   class BinHeap {
+
   public:
-
-    /// Type of the item-int map.
+    ///\e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
+    ///\e
     typedef PR Prio;
-    /// Type of the items stored in the heap.
+    ///\e
     typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
+    ///\e
     typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
+    ///\e
     typedef CMP Compare;
 
-    /// \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
+    /// \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
     /// heap's point of view, but may be useful to the user.
     ///
@@ -81 +85 @@
 
   public:
-
-    /// \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.
+    /// \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.
     explicit BinHeap(ItemIntMap &map) : _iim(map) {}
 
-    /// \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.
+    /// \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.
     BinHeap(ItemIntMap &map, const Compare &comp)
       : _iim(map), _comp(comp) {}
 
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
     int size() const { return _data.size(); }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _data.empty(); }
 
-    /// \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.
+    /// \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.
     void clear() {
       _data.clear();
@@ -125 +128 @@
     static int parent(int i) { return (i-1)/2; }
 
-    static int secondChild(int i) { return 2*i+2; }
+    static int second_child(int i) { return 2*i+2; }
     bool less(const Pair &p1, const Pair &p2) const {
       return _comp(p1.second, p2.second);
     }
 
-    int bubbleUp(int hole, Pair p) {
+    int bubble_up(int hole, Pair p) {
       int par = parent(hole);
       while( hole>0 && less(p,_data[par]) ) {
@@ -141 +144 @@
     }
 
-    int bubbleDown(int hole, Pair p, int length) {
-      int child = secondChild(hole);
+    int bubble_down(int hole, Pair p, int length) {
+      int child = second_child(hole);
       while(child < length) {
         if( less(_data[child-1], _data[child]) ) {
@@ -151 +154 @@
         move(_data[child], hole);
         hole = child;
-        child = secondChild(hole);
+        child = second_child(hole);
       }
       child--;
@@ -169 +172 @@
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \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);
-      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.
+      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.
     /// \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 Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \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.
     Item top() const {
       return _data[0].first;
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority relative to \c Compare.
+    ///
+    /// It returns the minimum priority relative to \c Compare.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       return _data[0].second;
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \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.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -215 +215 @@
       _iim.set(_data[0].first, POST_HEAP);
       if (n > 0) {
-        bubbleDown(0, _data[n], n);
+        bubble_down(0, _data[n], n);
       }
       _data.pop_back();
     }
 
-    /// \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.
+    /// \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.
     void erase(const Item &i) {
       int h = _iim[i];
@@ -231 +230 @@
       _iim.set(_data[h].first, POST_HEAP);
       if( h < n ) {
-        if ( bubbleUp(h, _data[n]) == h) {
-          bubbleDown(h, _data[n], n);
+        if ( bubble_up(h, _data[n]) == h) {
+          bubble_down(h, _data[n], n);
         }
       }
@@ -238 +237 @@
     }
 
-    /// \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.
+
+    /// \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.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
@@ -248 +248 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     /// \param p The priority.
@@ -262 +261 @@
       }
       else if( _comp(p, _data[idx].second) ) {
-        bubbleUp(idx, Pair(i,p));
+        bubble_up(idx, Pair(i,p));
       }
       else {
-        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.
+        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.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
+    /// \pre \c i must be stored in the heap with priority at least \c
+    /// p relative to \c Compare.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      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.
+      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.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      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.
+      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.
     /// \param i The item.
     State state(const Item &i) const {
@@ -306 +307 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -327 +328 @@
     }
 
-    /// \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.
+    /// \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.
     void replace(const Item& i, const Item& j) {
       int idx = _iim[i];

lemon/bits/map_extender.h

@@ -50 +50 @@
     typedef typename Parent::ConstReference ConstReference;
 
-    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
-
     class MapIt;
     class ConstMapIt;
@@ -194 +192 @@
     typedef typename Parent::ConstReference ConstReference;
 
-    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
-
     class MapIt;
     class ConstMapIt;

lemon/bucket_heap.h

@@ -20 +20 @@
 #define LEMON_BUCKET_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Bucket heap implementation.
+///\brief Bucket Heap implementation.
 
 #include <vector>
@@ -54 +54 @@
   }
 
-  /// \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
+  /// \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.
   template <typename IM, bool MIN = true>
   class BucketHeap {
 
   public:
-
-    /// Type of the item-int map.
+    /// \e
+    typedef typename IM::Key Item;
+    /// \e
+    typedef int Prio;
+    /// \e
+    typedef std::pair<Item, Prio> Pair;
+    /// \e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// 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:
@@ -96 +90 @@
   public:
 
-    /// \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
+    /// \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
     /// heap's point of view, but may be useful to the user.
     ///
@@ -111 +105 @@
 
   public:
-
-    /// \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.
+    /// \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.
     explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
     int size() const { return _data.size(); }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _data.empty(); }
 
-    /// \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.
+    /// \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.
     void clear() {
       _data.clear(); _first.clear(); _minimum = 0;
@@ -143 +135 @@
   private:
 
-    void relocateLast(int idx) {
+    void relocate_last(int idx) {
       if (idx + 1 < int(_data.size())) {
         _data[idx] = _data.back();
@@ -183 +175 @@
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \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);
@@ -196 +185 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \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();
@@ -211 +198 @@
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       while (_first[_minimum] == -1) {
@@ -222 +209 @@
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
@@ -233 +220 @@
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -244 +231 @@
       _iim[_data[idx].item] = -2;
       unlace(idx);
-      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.
+      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.
     void erase(const Item &i) {
       int idx = _iim[i];
       _iim[_data[idx].item] = -2;
       unlace(idx);
-      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.
+      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.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
@@ -270 +257 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     /// \param p The priority.
@@ -289 +275 @@
     }
 
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+    /// \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.
     /// \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];
@@ -305 +292 @@
     }
 
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+    /// \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.
     /// \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];
@@ -318 +306 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     State state(const Item &i) const {
@@ -332 +320 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -372 +360 @@
   }; // class BucketHeap
 
-  /// \ingroup heaps
-  ///
-  /// \brief Simplified bucket heap data structure.
+  /// \ingroup auxdat
+  ///
+  /// \brief A Simplified Bucket Heap implementation.
   ///
   /// This class implements a simplified \e bucket \e heap data
-  /// 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.
+  /// 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.
   ///
   /// \sa BucketHeap
@@ -401 +383 @@
 
   public:
-
-    /// Type of the item-int map.
+    typedef typename IM::Key Item;
+    typedef int Prio;
+    typedef std::pair<Item, Prio> Pair;
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// 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:
@@ -417 +394 @@
   public:
 
-    /// \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
+    /// \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
     /// heap's point of view, but may be useful to the user.
     ///
@@ -433 +410 @@
   public:
 
-    /// \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.
+    /// \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.
     explicit SimpleBucketHeap(ItemIntMap &map)
       : _iim(map), _free(-1), _num(0), _minimum(0) {}
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// \brief Returns the number of items stored in the heap.
+    ///
+    /// The number of items stored in the heap.
     int size() const { return _num; }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _num == 0; }
 
-    /// \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.
+    /// \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.
     void clear() {
       _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
@@ -465 +441 @@
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \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);
@@ -475 +449 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \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;
@@ -500 +472 @@
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       while (_first[_minimum] == -1) {
@@ -511 +483 @@
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
@@ -522 +494 @@
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -538 +510 @@
     }
 
-    /// \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.
+    /// \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.
     Prio operator[](const Item &i) const {
-      for (int k = 0; k < int(_first.size()); ++k) {
+      for (int k = 0; k < _first.size(); ++k) {
         int idx = _first[k];
         while (idx != -1) {
@@ -558 +531 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     State state(const Item &i) const {

lemon/cbc.cc

@@ -95 +95 @@
   }
 
-  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

@@ -63 +63 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);

lemon/circulation.h

@@ -73 +73 @@
     /// 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.
@@ -92 +88 @@
     /// The elevator type used by the algorithm.
     ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
+    /// \sa Elevator
+    /// \sa LinkedElevator
     typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
 
     /// \brief Instantiates an Elevator.
@@ -458 +451 @@
     }
 
-    /// \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) {
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
+    Circulation& tolerance(const Tolerance& tolerance) const {
       _tol = tolerance;
       return *this;
@@ -469 +461 @@
     /// \brief Returns a const reference to the tolerance.
     ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
+    /// Returns a const reference to the tolerance.
     const Tolerance& tolerance() const {
-      return _tol;
+      return tolerance;
     }
 
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call \ref run().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
+    /// If you need more control on the initial solution or the execution,
+    /// first you have to call one of the \ref init() functions, then
     /// the \ref start() function.
 

lemon/clp.cc

@@ -79 +79 @@
   }
 
-  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

@@ -76 +76 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);

lemon/concepts/digraph.h

@@ -36 +36 @@
     /// \brief Class describing the concept of directed graphs.
     ///
-    /// This class describes the common interface of all directed
-    /// graphs (digraphs).
+    /// This class describes the \ref concept "concept" of the
+    /// immutable directed digraphs.
     ///
-    /// 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.
+    /// Note that actual digraph implementation like @ref ListDigraph or
+    /// @ref SmartDigraph may have several additional functionality.
     ///
-    /// \sa Graph
+    /// \sa concept
     class Digraph {
     private:
-      /// 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.
+      ///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.
+
       void operator=(const Digraph &) {}
-
     public:
-      /// Default constructor.
+      ///\e
+
+      /// Defalult constructor.
+
+      /// Defalult constructor.
+      ///
       Digraph() { }
-
-      /// The node type of the digraph
+      /// Class for identifying a node of the digraph
 
       /// This class identifies a node of the digraph. It also serves
       /// as a base class of the node iterators,
-      /// thus they convert to this type.
+      /// thus they will convert to this type.
       class Node {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Node() { }
         /// Copy constructor.
@@ -77 +83 @@
         Node(const Node&) { }
 
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator 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 \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Node) const { return true; }
 
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Node n)
+        ///
         bool operator!=(Node) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// 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.
+        /// 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.
         bool operator<(Node) const { return false; }
-      };
-
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the digraph.
+
+      };
+
+      /// 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 a digraph \c g of type \c %Digraph like this:
+      /// of nodes in digraph \c g of type \c Digraph like this:
       ///\code
       /// int count=0;
@@ -118 +125 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         NodeIt() { }
         /// Copy constructor.
@@ -126 +133 @@
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// Initialize 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 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.
-        ///
+        /// 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.
         NodeIt(const Digraph&, const Node&) { }
         /// Next node.
@@ -149 +158 @@
 
 
-      /// The arc type of the digraph
+      /// Class for identifying an arc of the digraph
 
       /// This class identifies an arc of the digraph. It also serves
@@ -158 +167 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -166 +175 @@
         ///
         Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Arc(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Arc n)
+        ///
         bool operator!=(Arc) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// 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.
+        /// 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.
         bool operator<(Arc) const { return false; }
       };
 
-      /// Iterator class for the outgoing arcs of a node.
+      /// This iterator goes trough the outgoing arcs of a node.
 
       /// This iterator goes trough the \e outgoing arcs of a certain node
@@ -199 +208 @@
       /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
-      /// in a digraph \c g of type \c %Digraph as follows.
+      /// in digraph \c g of type \c Digraph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class OutArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
@@ -216 +226 @@
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
+        /// This constructor sets the iterator to the first outgoing arc.
+
+        /// This constructor sets the iterator to the first outgoing arc of
+        /// the node.
         OutArcIt(const Digraph&, const Node&) { }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// 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.
         OutArcIt(const Digraph&, const Arc&) { }
-        /// Next outgoing arc
+        ///Next outgoing arc
 
         /// Assign the iterator to the next
@@ -238 +249 @@
       };
 
-      /// Iterator class for the incoming arcs of a node.
+      /// This iterator goes trough 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 incoming arcs of a node \c n
-      /// in a digraph \c g of type \c %Digraph as follows.
+      /// of outgoing arcs of a node \c n
+      /// in digraph \c g of type \c Digraph as follows.
       ///\code
       /// int count=0;
-      /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class InArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         InArcIt() { }
         /// Copy constructor.
@@ -261 +273 @@
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
+        /// This constructor sets the iterator to first incoming arc.
+
+        /// This constructor set the iterator to the first incoming arc of
+        /// the node.
         InArcIt(const Digraph&, const Node&) { }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// 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.
         InArcIt(const Digraph&, const Arc&) { }
         /// Next incoming arc
 
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
+        /// Assign the iterator to the next inarc of the corresponding node.
+        ///
         InArcIt& operator++() { return *this; }
       };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each arc of the digraph.
+      /// 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:
+      /// of arcs in a digraph \c g of type \c Digraph as follows:
       ///\code
       /// int count=0;
-      /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
+      /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
       ///\endcode
       class ArcIt : public Arc {
@@ -296 +308 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         ArcIt() { }
         /// Copy constructor.
@@ -304 +316 @@
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         ArcIt(Invalid) { }
-        /// 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.
-        ///
+        /// 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.
         ArcIt(const Digraph&, const Arc&) { }
-        /// Next arc
+        ///Next arc
 
         /// Assign the iterator to the next arc.
-        ///
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
+      ///Gives back the target node of an arc.
+
+      ///Gives back the target node of an 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 The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
-      Node target(Arc) const { return INVALID; }
-
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
+      /// \brief Returns the ID of the node.
       int id(Node) const { return -1; }
 
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
+      /// \brief Returns the ID of the arc.
       int id(Arc) const { return -1; }
 
-      /// \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.
+      /// \brief 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 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.
+      /// \brief 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 An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
+      /// \brief Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
 
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
+      /// \brief Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
 
@@ -391 +393 @@
       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.
       ///
-      /// 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; }
+      /// Gives back the base node of the iterator.
+      /// It is always the target of the pointed arc.
+      Node baseNode(const InArcIt&) 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; }
+      /// Gives back the running node of the iterator.
+      /// It is always the source of the pointed arc.
+      Node runningNode(const InArcIt&) 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; }
+      /// Gives back the base node of the iterator.
+      /// It is always the source of the pointed arc.
+      Node baseNode(const OutArcIt&) 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; }
-
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
+      /// 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.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
       public:
 
-        /// Constructor
-        explicit NodeMap(const Digraph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Digraph&) { }
+        ///\e
         NodeMap(const Digraph&, T) { }
 
@@ -445 +446 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
       public:
 
-        /// Constructor
-        explicit ArcMap(const Digraph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Digraph&) { }
+        ///\e
         ArcMap(const Digraph&, T) { }
-
       private:
         ///Copy constructor

lemon/concepts/graph.h

@@ -19 +19 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concept of undirected graphs.
+///\brief The concept of Undirected Graphs.
 
 #ifndef LEMON_CONCEPTS_GRAPH_H
@@ -25 +25 @@
 
 #include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
 #include <lemon/core.h>
 
@@ -34 +32 @@
     /// \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.
     ///
-    /// 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
+    /// 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
     /// run properly, of course.
-    /// An actual graph implementation like \ref ListGraph or
-    /// \ref SmartGraph may have additional functionality.    
     ///
-    /// 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.
+    /// 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.
     ///
-    /// 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.
+    /// 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.
     ///
-    /// 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
+    /// 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.
     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:
-      /// 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
+      /// \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
       /// specializations for undirected graphs.
       typedef True UndirectedTag;
 
-      /// 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.
+      /// \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.
       class Node {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Node() { }
         /// Copy constructor.
@@ -109 +96 @@
         Node(const Node&) { }
 
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator 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 \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Node) const { return true; }
 
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Node n)
+        ///
         bool operator!=(Node) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
+        /// 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.
@@ -138 +125 @@
       };
 
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the graph.
+      /// 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 a graph \c g of type \c %Graph like this:
+      /// of nodes in graph \c g of type \c Graph like this:
       ///\code
       /// int count=0;
@@ -151 +138 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         NodeIt() { }
         /// Copy constructor.
@@ -159 +146 @@
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// Initialize 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 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.
-        ///
+        /// 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.
         NodeIt(const Graph&, const Node&) { }
         /// Next node.
@@ -182 +171 @@
 
 
-      /// 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.
+      /// The base type of the edge iterators.
+
+      /// The base type of the edge iterators.
+      ///
       class Edge {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Edge() { }
         /// Copy constructor.
@@ -199 +187 @@
         ///
         Edge(const Edge&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Edge(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Edge) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Edge n)
+        ///
         bool operator!=(Edge) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// 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.
+        /// 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.
         bool operator<(Edge) const { return false; }
       };
 
-      /// Iterator class for the edges.
-
-      /// This iterator goes through each edge of the graph.
+      /// 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:
+      /// of edges in a graph \c g of type \c Graph as follows:
       ///\code
       /// int count=0;
@@ -239 +227 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         EdgeIt() { }
         /// Copy constructor.
@@ -247 +235 @@
         ///
         EdgeIt(const EdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         EdgeIt(Invalid) { }
-        /// 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.
-        ///
+        /// 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.
         EdgeIt(const Graph&, const Edge&) { }
         /// Next edge
 
         /// Assign the iterator to the next edge.
-        ///
         EdgeIt& operator++() { return *this; }
       };
 
-      /// Iterator class for the incident edges of a node.
-
-      /// This iterator goes trough the incident undirected edges
-      /// of a certain node of a graph.
+      /// \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. the number of incident edges) of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// degree (i.e. count the number of incident arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
       ///
       ///\code
@@ -281 +272 @@
       /// 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
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         IncEdgeIt() { }
         /// Copy constructor.
@@ -295 +284 @@
         ///
         IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         IncEdgeIt(Invalid) { }
-        /// Sets the iterator to the first incident edge.
-
-        /// Sets the iterator to the first incident edge of the given node.
-        ///
+        /// This constructor sets the iterator to first incident arc.
+
+        /// This constructor set the iterator to the first incident arc of
+        /// the node.
         IncEdgeIt(const Graph&, const Node&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
+        /// 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.
         IncEdgeIt(const Graph&, const Edge&) { }
-        /// Next incident edge
-
-        /// Assign the iterator to the next incident edge
+        /// Next incident arc
+
+        /// Assign the iterator to the next incident arc
         /// of the corresponding node.
         IncEdgeIt& operator++() { return *this; }
       };
 
-      /// 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.
+      /// The directed arc type.
+
+      /// The directed arc type. It can be converted to the
+      /// edge or it should be inherited from the undirected
+      /// edge.
       class Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -334 +324 @@
         ///
         Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Arc(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Arc n)
+        ///
         bool operator!=(Arc) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// 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.
+        /// 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.
         bool operator<(Arc) const { return false; }
 
-        /// Converison to \c Edge
-        
-        /// Converison to \c Edge.
-        ///
+        /// Converison to Edge
         operator Edge() const { return Edge(); }
       };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each directed arc of the graph.
+      /// 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:
+      /// of arcs in a graph \c g of type \c Graph as follows:
       ///\code
       /// int count=0;
-      /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
+      /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
       ///\endcode
       class ArcIt : public Arc {
@@ -380 +366 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         ArcIt() { }
         /// Copy constructor.
@@ -388 +374 @@
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         ArcIt(Invalid) { }
-        /// 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.
-        ///
+        /// 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.
         ArcIt(const Graph&, const Arc&) { }
-        /// Next arc
+        ///Next arc
 
         /// Assign the iterator to the next arc.
-        ///
         ArcIt& operator++() { return *this; }
       };
 
-      /// 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.
+      /// 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
       /// of outgoing arcs of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// in graph \c g of type \c Graph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class OutArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
@@ -433 +420 @@
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
+        /// 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
         OutArcIt(const Graph& n, const Node& g) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
         }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// 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.
         OutArcIt(const Graph&, const Arc&) { }
-        /// Next outgoing arc
+        ///Next outgoing arc
 
         /// Assign the iterator to the next
@@ -458 +448 @@
       };
 
-      /// 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.
+      /// 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 incoming arcs of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// of outgoing arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class InArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         InArcIt() { }
         /// Copy constructor.
@@ -481 +472 @@
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
+        /// 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
         InArcIt(const Graph& g, const Node& n) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
         }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// 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.
         InArcIt(const Graph&, const Arc&) { }
         /// Next incoming arc
 
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
+        /// Assign the iterator to the next inarc of the corresponding node.
+        ///
         InArcIt& operator++() { return *this; }
       };
 
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&>
@@ -515 +508 @@
       public:
 
-        /// Constructor
-        explicit NodeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Graph&) { }
+        ///\e
         NodeMap(const Graph&, T) { }
 
@@ -532 +525 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
@@ -541 +533 @@
       public:
 
-        /// Constructor
-        explicit ArcMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Graph&) { }
+        ///\e
         ArcMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
@@ -558 +549 @@
       };
 
-      /// \brief Standard graph map type for the edges.
-      ///
-      /// Standard graph map type for the edges.
-      /// It conforms to the ReferenceMap concept.
+      /// Reference map of the edges to type \c T.
+
+      /// Reference map of the edges to type \c T.
       template<class T>
       class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
@@ -567 +557 @@
       public:
 
-        /// Constructor
-        explicit EdgeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        EdgeMap(const Graph&) { }
+        ///\e
         EdgeMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
@@ -584 +573 @@
       };
 
-      /// \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.
+      /// \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.
       /// \sa v()
       /// \sa direction()
       Node u(Edge) const { return INVALID; }
 
-      /// \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.
+      /// \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.
       /// \sa u()
       /// \sa direction()
       Node v(Edge) const { return INVALID; }
 
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
+      /// \brief Source node of the directed arc.
       Node source(Arc) const { return INVALID; }
 
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
+      /// \brief Target node of the directed arc.
       Node target(Arc) const { return INVALID; }
 
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
+      /// \brief Returns the id of the node.
       int id(Node) const { return -1; }
 
-      /// \brief The ID of the edge.
-      ///
-      /// Returns the ID of the given edge.
+      /// \brief Returns the id of the edge.
       int id(Edge) const { return -1; }
 
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
+      /// \brief Returns the id of the arc.
       int id(Arc) const { return -1; }
 
-      /// \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.
+      /// \brief 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 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.
+      /// \brief 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 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.
+      /// \brief 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 An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
+      /// \brief Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
 
-      /// \brief An upper bound on the edge IDs.
-      ///
-      /// Returns an upper bound on the edge IDs.
+      /// \brief Returns an upper bound on the edge IDs.
       int maxEdgeId() const { return -1; }
 
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
+      /// \brief 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 {}
@@ -734 +706 @@
       int maxId(Arc) const { return -1; }
 
-      /// \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; }
+      /// \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;
+      }
 
       template <typename _Graph>

lemon/concepts/graph_components.h

@@ -93 +93 @@
       /// associative containers (e.g. \c std::map).
       ///
-      /// \note This operator only has to define some strict ordering of
+      /// \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.

lemon/concepts/heap.h

@@ -17 +17 @@
  */
 
-#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>
@@ -36 +36 @@
     /// \brief The heap concept.
     ///
-    /// 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.
+    /// 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.
     ///
-    /// 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
+    /// \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 comparing the priorities.
+    /// \tparam Comp A functor class for the ordering of the priorities.
     /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
-    template <typename PR, typename IM, typename CMP>
+    template <typename PR, typename IM, typename Comp = std::less<PR> >
 #else
-    template <typename PR, typename IM, typename CMP = std::less<PR> >
+    template <typename PR, typename IM>
 #endif
     class Heap {
@@ -71 +65 @@
       ///
       /// 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.
+      /// "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.
       ///
       /// The item-int map must be initialized in such way that it assigns
@@ -78 +73 @@
       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 Constructor.
-      ///
-      /// Constructor.
+      /// \brief The constructor.
+      ///
+      /// The 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.
+      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
       explicit Heap(ItemIntMap &map) {}
 
-      /// \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.
-      explicit Heap(ItemIntMap &map, const CMP &comp) {}
-
       /// \brief The number of items stored in the heap.
       ///
-      /// This function returns the number of items stored in the heap.
+      /// Returns the number of items stored in the heap.
       int size() const { return 0; }
 
-      /// \brief Check if the heap is empty.
-      ///
-      /// This function returns \c true if the heap is empty.
+      /// \brief Checks if the heap is empty.
+      ///
+      /// Returns \c true if the heap is empty.
       bool empty() const { return false; }
 
-      /// \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.
+      /// \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.
       /// \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) {}
 
-      /// \brief Return the item having minimum priority.
-      ///
-      /// This function returns the item having minimum priority.
+      /// \brief Returns the item having minimum priority.
+      ///
+      /// Returns the item having minimum priority.
       /// \pre The heap must be non-empty.
       Item top() const {}
@@ -137 +116 @@
       /// \brief The minimum priority.
       ///
-      /// This function returns the minimum priority.
+      /// Returns the minimum priority.
       /// \pre The heap must be non-empty.
       Prio prio() const {}
 
-      /// \brief Remove the item having minimum priority.
-      ///
-      /// This function removes the item having minimum priority.
+      /// \brief Removes the item having minimum priority.
+      ///
+      /// Removes the item having minimum priority.
       /// \pre The heap must be non-empty.
       void pop() {}
 
-      /// \brief Remove the given item from the heap.
-      ///
-      /// This function removes the given item from the heap if it is
-      /// already stored.
+      /// \brief Removes an item from the heap.
+      ///
+      /// 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) {}
 
-      /// \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.
+      /// \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.
       Prio operator[](const Item &i) const {}
 
-      /// \brief Set the priority of an item or insert it, if it is
+      /// \brief Sets the priority of an item or inserts 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.
+      /// already stored in the heap.
+      /// Otherwise it inserts the given item with the given priority.
       ///
       /// \param i The item.
@@ -173 +150 @@
       void set(const Item &i, const Prio &p) {}
 
-      /// \brief Decrease the priority of an item to the given value.
-      ///
-      /// This function decreases the priority of an item to the given value.
+      /// \brief Decreases the priority of an item to the given value.
+      ///
+      /// 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.
+      /// \pre \c i must be stored in the heap with priority at least \c p.
       void decrease(const Item &i, const Prio &p) {}
 
-      /// \brief Increase the priority of an item to the given value.
-      ///
-      /// This function increases the priority of an item to the given value.
+      /// \brief Increases the priority of an item to the given value.
+      ///
+      /// 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.
+      /// \pre \c i must be stored in the heap with priority at most \c p.
       void increase(const Item &i, const Prio &p) {}
 
-      /// \brief Return the state of an item.
+      /// \brief Returns if an item is in, has already been in, or has
+      /// never been in the heap.
       ///
       /// This method returns \c PRE_HEAP if the given item has never
@@ -199 +177 @@
       State state(const Item &i) const {}
 
-      /// \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.
+      /// \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.
       /// \param i The item.
       /// \param st The state. It should not be \c IN_HEAP.

lemon/concepts/maps.h

@@ -183 +183 @@
       template<typename _ReferenceMap>
       struct Constraints {
-        typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type
-        constraints() {
+        void constraints() {
           checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
           ref = m[key];

lemon/cplex.cc

@@ -112 +112 @@
   }
 
-  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

@@ -94 +94 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);

lemon/dfs.h

@@ -48 +48 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -63 +63 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -83 +82 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -98 +97 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
@@ -226 +225 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
@@ -246 +245 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
@@ -266 +265 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
@@ -286 +285 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
@@ -413 +412 @@
     ///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 better control on the execution, you have to call
-    ///\ref init() first, then you can add a source node with \ref addSource()
+    ///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()
     ///and perform the actual computation with \ref start().
     ///This procedure can be repeated if there are nodes that have not
@@ -671 +670 @@
     ///@{
 
-    ///The DFS path to the given node.
-
-    ///Returns the DFS path to the given node from the root(s).
+    ///The DFS path to a node.
+
+    ///Returns the DFS path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -681 +680 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -692 +691 @@
     int dist(Node v) const { return (*_dist)[v]; }
 
-    ///Returns the 'previous arc' of the %DFS tree for the given node.
+    ///Returns the 'previous arc' of the %DFS tree for a node.
 
     ///This function returns the 'previous arc' of the %DFS tree for the
@@ -700 +699 @@
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
-    ///\ref predNode() and \ref predMap().
+    ///\ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -706 +705 @@
     Arc predArc(Node v) const { return (*_pred)[v];}
 
-    ///Returns the 'previous node' of the %DFS tree for the given node.
+    ///Returns the 'previous node' of the %DFS tree.
 
     ///This function returns the 'previous node' of the %DFS
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a %DFS path from a root to \c v. It is \c INVALID
+    ///from 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() and \ref predMap().
+    ///\ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -735 +734 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the DFS tree (forest).
+    ///arcs, which form the DFS tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -741 +740 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node. node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -767 +766 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -782 +781 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
@@ -802 +801 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -817 +816 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
@@ -832 +831 @@
 
     ///The type of the DFS paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -838 +837 @@
   /// Default traits class used by DfsWizard
 
-  /// Default traits class used by DfsWizard.
-  /// \tparam GR The type of the digraph.
+  /// 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.
   template<class GR>
   class DfsWizardBase : public DfsWizardDefaultTraits<GR>
@@ -867 +870 @@
     /// Constructor.
 
-    /// This constructor does not require parameters, it initiates
+    /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to \c 0.
     DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -897 +900 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -904 +908 @@
     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;
 
@@ -990 +1000 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     DfsWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1009 +1018 @@
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
     template<class T>
     DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
@@ -1028 +1036 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     DfsWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1048 +1054 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1204 +1209 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1365 +1370 @@
     /// 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 better control on the execution, you have to call
-    /// \ref init() first, then you can add a source node with \ref addSource()
+    /// 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()
     /// and perform the actual computation with \ref start().
     /// This procedure can be repeated if there are nodes that have not
@@ -1616 +1621 @@
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
+    /// \brief Checks if a node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).

lemon/dijkstra.h

@@ -71 +71 @@
 
     ///The type of the map that stores the arc lengths.
-    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename LEN::Value Value;
 
@@ -117 +117 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -132 +132 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
@@ -152 +152 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a \c DistMap.
@@ -169 +169 @@
   /// \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
@@ -206 +202 @@
     typedef typename TR::Digraph Digraph;
 
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename TR::LengthMap::Value Value;
     ///The type of the map that stores the arc lengths.
@@ -309 +305 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap
@@ -330 +326 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap
@@ -351 +347 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap
@@ -448 +444 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c OperationTraits type.
-    /// For more information see \ref DijkstraDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
@@ -590 +585 @@
     ///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 better control on the execution, you have to call
-    ///\ref init() first, then you can add several source nodes with
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), 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.
@@ -807 +802 @@
     ///The results of the %Dijkstra algorithm can be obtained using these
     ///functions.\n
-    ///Either \ref run(Node) "run()" or \ref init() should be called
+    ///Either \ref run(Node) "run()" or \ref start() should be called
     ///before using them.
 
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns the shortest path to the given node from the root(s).
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -822 +817 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -833 +828 @@
     Value dist(Node v) const { return (*_dist)[v]; }
 
-    ///\brief Returns the 'previous arc' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous arc' of the shortest path tree for a 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
@@ -842 +836 @@
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predNode() and \ref predMap().
+    ///tree used in \ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -848 +842 @@
     Arc predArc(Node v) const { return (*_pred)[v]; }
 
-    ///\brief Returns the 'previous node' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous node' of the shortest path tree for a 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
-    ///of a shortest path from a root to \c v. It is \c INVALID
+    ///from 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() and \ref predMap().
+    ///tree used in \ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -878 +871 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
+    ///arcs, which form the shortest path tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -884 +877 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -903 +896 @@
                                           Heap::POST_HEAP; }
 
-    ///The current distance of the given node from the root(s).
-
-    ///Returns the current distance of the given node from the root(s).
+    ///The current distance of a node from the root(s).
+
+    ///Returns the current distance of a node from the root(s).
     ///It may be decreased in the following processes.
     ///
@@ -932 +925 @@
 
     ///The type of the map that stores the arc lengths.
-    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename LEN::Value Value;
 
@@ -981 +974 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -996 +989 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
@@ -1016 +1009 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a DistMap.
@@ -1031 +1024 @@
 
     ///The type of the shortest paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -1037 +1030 @@
   /// Default traits class used by DijkstraWizard
 
-  /// Default traits class used by DijkstraWizard.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
+  /// 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.
   template<typename GR, typename LEN>
   class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
@@ -1098 +1094 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -1105 +1102 @@
     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;
 
@@ -1182 +1187 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1201 +1205 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1221 +1223 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\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.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1239 +1240 @@
       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

@@ -22 +22 @@
 #include <iostream>
 
-///\ingroup geomdat
+///\ingroup misc
 ///\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 {
@@ -34 +41 @@
   namespace dim2 {
 
-  /// \addtogroup geomdat
+  /// \addtogroup misc
   /// @{
 

lemon/fib_heap.h

@@ -21 +21 @@
 
 ///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
+///\ingroup auxdat
+///\brief Fibonacci Heap implementation.
 
 #include <vector>
-#include <utility>
 #include <functional>
 #include <lemon/math.h>
@@ -31 +30 @@
 namespace lemon {
 
-  /// \ingroup heaps
+  /// \ingroup auxdat
   ///
-  /// \brief Fibonacci heap data structure.
+  ///\brief Fibonacci Heap.
   ///
-  /// This class implements the \e Fibonacci \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///This class implements the \e Fibonacci \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. \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.
   ///
-  /// The methods \ref increase() and \ref erase() are not efficient in a
-  /// Fibonacci heap. In case of many calls of these operations, it is
-  /// better to use other heap structure, e.g. \ref BinHeap "binary heap".
+  ///The methods \ref increase and \ref erase are not efficient in a Fibonacci
+  ///heap. In case of many calls to these operations, it is better to use a
+  ///\ref BinHeap "binary heap".
   ///
-  /// \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>.
+  ///\param PRIO Type of the priority of the items.
+  ///\param IM A read and writable Item int map, used internally
+  ///to handle the cross references.
+  ///\param CMP A class for the ordering of the priorities. The
+  ///default is \c std::less<PRIO>.
+  ///
+  ///\sa BinHeap
+  ///\sa Dijkstra
 #ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
+  template <typename PRIO, typename IM, typename CMP>
 #else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
+  template <typename PRIO, typename IM, typename CMP = std::less<PRIO> >
 #endif
   class FibHeap {
   public:
-
-    /// Type of the item-int map.
+    ///\e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
+    ///\e
+    typedef PRIO Prio;
+    ///\e
     typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
+    ///\e
     typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
+    ///\e
     typedef CMP Compare;
 
@@ -77 +81 @@
   public:
 
-    /// \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
+    /// \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
     /// heap's point of view, but may be useful to the user.
     ///
@@ -91 +95 @@
     };
 
-    /// \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.
+    /// \brief The constructor
+    ///
+    /// \c map should be given to the constructor, since it is
+    ///   used internally to handle the cross references.
     explicit FibHeap(ItemIntMap &map)
       : _minimum(0), _iim(map), _num() {}
 
-    /// \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.
+    /// \brief The constructor
+    ///
+    /// \c map should be given to the constructor, since it is used
+    /// internally to handle the cross references. \c comp is an
+    /// object for ordering of the priorities.
     FibHeap(ItemIntMap &map, const Compare &comp)
       : _minimum(0), _iim(map), _comp(comp), _num() {}
@@ -112 +112 @@
     /// \brief The number of items stored in the heap.
     ///
-    /// This function returns the number of items stored in the heap.
+    /// Returns the number of items stored in the heap.
     int size() const { return _num; }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    ///   Returns \c true if and only if the heap stores no items.
     bool empty() const { return _num==0; }
 
-    /// \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.
+    /// \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.
     void clear() {
       _data.clear(); _minimum = 0; _num = 0;
     }
 
-    /// \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 item The item to insert.
-    /// \param prio The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& prio) {
+    /// \brief \c item gets to the heap with priority \c value independently
+    /// if \c item was already there.
+    ///
+    /// This method calls \ref push(\c item, \c value) if \c item is not
+    /// stored in the heap and it calls \ref decrease(\c item, \c value) or
+    /// \ref increase(\c item, \c value) otherwise.
+    void set (const Item& item, const Prio& value) {
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
+      } else push(item, value);
+    }
+
+    /// \brief Adds \c item to the heap with priority \c value.
+    ///
+    /// Adds \c item to the heap with priority \c value.
+    /// \pre \c item must not be stored in the heap.
+    void push (const Item& item, const Prio& value) {
       int i=_iim[item];
       if ( i < 0 ) {
@@ -159 +169 @@
         _data[_minimum].right_neighbor=i;
         _data[i].left_neighbor=_minimum;
-        if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
+        if ( _comp( value, _data[_minimum].prio) ) _minimum=i;
       } else {
         _data[i].right_neighbor=_data[i].left_neighbor=i;
         _minimum=i;
       }
-      _data[i].prio=prio;
+      _data[i].prio=value;
       ++_num;
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \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.
     Item top() const { return _data[_minimum].name; }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[_minimum].prio; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Returns the minimum priority relative to \c Compare.
+    ///
+    /// It returns the minimum priority relative to \c Compare.
+    /// \pre The heap must be nonempty.
+    const Prio& prio() const { return _data[_minimum].prio; }
+
+    /// \brief Returns the priority of \c item.
+    ///
+    /// It returns the priority of \c item.
+    /// \pre \c item must be in the heap.
+    const Prio& operator[](const Item& item) const {
+      return _data[_iim[item]].prio;
+    }
+
+    /// \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.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -189 +209 @@
         _data[_minimum].in=false;
         if ( _data[_minimum].degree!=0 ) {
-          makeRoot(_data[_minimum].child);
+          makeroot(_data[_minimum].child);
           _minimum=_data[_minimum].child;
           balance();
@@ -202 +222 @@
           int last_child=_data[child].left_neighbor;
 
-          makeRoot(child);
+          makeroot(child);
 
           _data[left].right_neighbor=child;
@@ -215 +235 @@
     }
 
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
+    /// \brief Deletes \c item from the heap.
+    ///
+    /// This method deletes \c item from the heap, if \c item was already
+    /// stored in the heap. It is quite inefficient in Fibonacci heaps.
     void erase (const Item& item) {
       int i=_iim[item];
@@ -235 +253 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    Prio operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \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 item The item.
-    /// \param prio The priority.
-    void set (const Item& item, const Prio& prio) {
+    /// \brief Decreases the priority of \c item to \c value.
+    ///
+    /// This method decreases the priority of \c item to \c value.
+    /// \pre \c item must be stored in the heap with priority at least \c
+    ///   value relative to \c Compare.
+    void decrease (Item item, const Prio& value) {
       int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        if ( _comp(prio, _data[i].prio) ) decrease(item, prio);
-        if ( _comp(_data[i].prio, prio) ) increase(item, prio);
-      } else push(item, prio);
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param prio The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e prio.
-    void decrease (const Item& item, const Prio& prio) {
-      int i=_iim[item];
-      _data[i].prio=prio;
+      _data[i].prio=value;
       int p=_data[i].parent;
 
-      if ( p!=-1 && _comp(prio, _data[p].prio) ) {
+      if ( p!=-1 && _comp(value, _data[p].prio) ) {
         cut(i,p);
         cascade(p);
       }
-      if ( _comp(prio, _data[_minimum].prio) ) _minimum=i;
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param prio The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e prio.
-    void increase (const Item& item, const Prio& prio) {
+      if ( _comp(value, _data[_minimum].prio) ) _minimum=i;
+    }
+
+    /// \brief Increases the priority of \c item to \c value.
+    ///
+    /// This method sets the priority of \c item to \c value. Though
+    /// there is no precondition on the priority of \c item, this
+    /// method should be used only if it is indeed necessary to increase
+    /// (relative to \c Compare) the priority of \c item, because this
+    /// method is inefficient.
+    void increase (Item item, const Prio& value) {
       erase(item);
-      push(item, prio);
-    }
-
-    /// \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 item The item.
+      push(item, value);
+    }
+
+
+    /// \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.
     State state(const Item &item) const {
       int i=_iim[item];
@@ -306 +299 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -373 +366 @@
     }
 
-    void makeRoot(int c) {
+    void makeroot(int c) {
       int s=c;
       do {

lemon/full_graph.h

@@ -25 +25 @@
 ///\ingroup graphs
 ///\file
-///\brief FullDigraph and FullGraph classes.
+///\brief FullGraph and FullDigraph classes.
 
 namespace lemon {
@@ -149 +149 @@
   /// \ingroup graphs
   ///
-  /// \brief A directed full graph class.
-  ///
-  /// FullDigraph is a simple and fast implmenetation of directed full
-  /// (complete) graphs. It contains an arc from each node to each node
-  /// (including a loop for each node), therefore the number of arcs
-  /// is the square of the number of nodes.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or arcs, however
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// \note FullDigraph and FullGraph classes are very similar,
+  /// \brief A full digraph class.
+  ///
+  /// This is a simple and fast directed full graph implementation.
+  /// From each node go arcs to each node (including the source node),
+  /// therefore the number of the arcs in the digraph is the square of
+  /// the node number. This digraph type is completely static, so you
+  /// can neither add nor delete either arcs or nodes, and it needs
+  /// constant space in memory.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph concept".
+  ///
+  /// The \c FullDigraph and \c FullGraph classes are very similar,
   /// but there are two differences. While this class conforms only
-  /// to the \ref concepts::Digraph "Digraph" concept, FullGraph
-  /// conforms to the \ref concepts::Graph "Graph" concept,
-  /// moreover FullGraph does not contain a loop for each
-  /// node as this class does.
+  /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
+  /// class conforms to the \ref concepts::Graph "Graph" concept,
+  /// moreover \c FullGraph does not contain a loop arc for each
+  /// node as \c FullDigraph does.
   ///
   /// \sa FullGraph
@@ -176 +174 @@
   public:
 
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and arcs will be zero.
+    /// \brief Constructor
     FullDigraph() { construct(0); }
 
@@ -189 +185 @@
     /// \brief Resizes the digraph
     ///
-    /// This function resizes the digraph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the digraph will be
+    /// Resizes the digraph. The function will fully destroy and
+    /// rebuild the digraph. This cause that the maps of the digraph will
     /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
@@ -202 +198 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is 
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
+    /// Returns the node with the given index. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -210 +206 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is 
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// \sa operator()()
+    /// Returns the index of the given node. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
     static int index(const Node& node) { return Parent::index(node); }
 
@@ -219 +215 @@
     ///
     /// Returns the arc connecting the given nodes.
-    Arc arc(Node u, Node v) const {
+    Arc arc(const Node& u, const Node& v) const {
       return Parent::arc(u, v);
     }
@@ -525 +521 @@
   /// \brief An undirected full graph class.
   ///
-  /// FullGraph is a simple and fast implmenetation of undirected full
-  /// (complete) graphs. It contains an edge between every distinct pair
-  /// of nodes, therefore the number of edges is <tt>n(n-1)/2</tt>.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// \note FullDigraph and FullGraph classes are very similar,
-  /// but there are two differences. While FullDigraph
+  /// This is a simple and fast undirected full graph
+  /// implementation. From each node go edge to each other node,
+  /// therefore the number of edges in the graph is \f$n(n-1)/2\f$.
+  /// This graph type is completely static, so you can neither
+  /// add nor delete either edges or nodes, and it needs constant
+  /// space in memory.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph concept".
+  ///
+  /// The \c FullGraph and \c FullDigraph classes are very similar,
+  /// but there are two differences. While the \c FullDigraph class
   /// conforms only to the \ref concepts::Digraph "Digraph" concept,
   /// this class conforms to the \ref concepts::Graph "Graph" concept,
-  /// moreover this class does not contain a loop for each
-  /// node as FullDigraph does.
+  /// moreover \c FullGraph does not contain a loop arc for each
+  /// node as \c FullDigraph does.
   ///
   /// \sa FullDigraph
@@ -549 +543 @@
   public:
 
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and edges will be zero.
+    /// \brief Constructor
     FullGraph() { construct(0); }
 
@@ -562 +554 @@
     /// \brief Resizes the graph
     ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
+    /// Resizes the graph. The function will fully destroy and
+    /// rebuild the graph. This cause that the maps of the graph will
     /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
@@ -577 +569 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is 
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
+    /// Returns the node with the given index. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -585 +577 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is 
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// \sa operator()()
+    /// Returns the index of the given node. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
     static int index(const Node& node) { return Parent::index(node); }
 
@@ -594 +586 @@
     ///
     /// Returns the arc connecting the given nodes.
-    Arc arc(Node s, Node t) const {
+    Arc arc(const Node& s, const Node& t) const {
       return Parent::arc(s, t);
     }
 
-    /// \brief Returns the edge connecting the given nodes.
-    ///
-    /// Returns the edge connecting the given nodes.
-    Edge edge(Node u, Node v) const {
+    /// \brief Returns the edge connects the given nodes.
+    ///
+    /// Returns the edge connects the given nodes.
+    Edge edge(const Node& u, const Node& v) const {
       return Parent::edge(u, v);
     }

lemon/glpk.cc

@@ -57 +57 @@
     int i = glp_add_rows(lp, 1);
     glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0);
-    return i;
-  }
-
-  int GlpkBase::_addRow(Value lo, ExprIterator b, 
-                        ExprIterator e, Value up) {
-    int i = glp_add_rows(lp, 1);
-
-    if (lo == -INF) {
-      if (up == INF) {
-        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
-      } else {
-        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-      }    
-    } else {
-      if (up == INF) {
-        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
-      } else if (lo != up) {        
-        glp_set_row_bnds(lp, i, GLP_DB, lo, up);
-      } else {
-        glp_set_row_bnds(lp, i, GLP_FX, lo, up);
-      }
-    }
-
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    indexes.push_back(0);
-    values.push_back(0);
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    glp_set_mat_row(lp, i, values.size() - 1,
-                    &indexes.front(), &values.front());
     return i;
   }

lemon/glpk.h

@@ -55 +55 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);

lemon/gomory_hu.h

@@ -360 +360 @@
     /// \c t.
     /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int cnt=0;
-    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
+    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
     /// \endcode
     class MinCutNodeIt
@@ -457 +457 @@
     /// \c t.
     /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int value=0;
-    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
+    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
     ///   value+=capacities[e];
     /// \endcode

lemon/grid_graph.h

@@ -471 +471 @@
   /// \brief Grid graph class
   ///
-  /// GridGraph implements a special graph type. The nodes of the
-  /// graph can be indexed by two integer values \c (i,j) where \c i is
-  /// in the range <tt>[0..width()-1]</tt> and j is in the range
-  /// <tt>[0..height()-1]</tt>. Two nodes are connected in the graph if
-  /// the indices differ exactly on one position and the difference is
-  /// also exactly one. The nodes of the graph can be obtained by position
-  /// using the \c operator()() function and the indices of the nodes can
-  /// be obtained using \c pos(), \c col() and \c row() members. The outgoing
+  /// This class implements a special graph type. The nodes of the
+  /// graph can be indexed by two integer \c (i,j) value where \c i is
+  /// in the \c [0..width()-1] range and j is in the \c
+  /// [0..height()-1] range.  Two nodes are connected in the graph if
+  /// the indexes differ exactly on one position and exactly one is
+  /// the difference. The nodes of the graph can be indexed by position
+  /// with the \c operator()() function. The positions of the nodes can be
+  /// get with \c pos(), \c col() and \c row() members. The outgoing
   /// arcs can be retrieved with the \c right(), \c up(), \c left()
   /// and \c down() functions, where the bottom-left corner is the
   /// origin.
-  ///
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however
-  /// the structure can be resized using resize().
   ///
   /// \image html grid_graph.png
@@ -501 +497 @@
   ///\endcode
   ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
+  /// This graph type fully conforms to the \ref concepts::Graph
+  /// "Graph concept".
   class GridGraph : public ExtendedGridGraphBase {
     typedef ExtendedGridGraphBase Parent;
@@ -509 +504 @@
   public:
 
-    /// \brief Map to get the indices of the nodes as \ref dim2::Point
-    /// "dim2::Point<int>".
-    ///
-    /// Map to get the indices of the nodes as \ref dim2::Point
-    /// "dim2::Point<int>".
+    /// \brief Map to get the indices of the nodes as dim2::Point<int>.
+    ///
+    /// Map to get the indices of the nodes as dim2::Point<int>.
     class IndexMap {
     public:
@@ -522 +515 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       IndexMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.pos(key);
@@ -544 +541 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       ColMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.col(key);
@@ -566 +567 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       RowMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.row(key);
@@ -579 +584 @@
     /// \brief Constructor
     ///
-    /// Construct a grid graph with the given size.
+    /// Construct a grid graph with given size.
     GridGraph(int width, int height) { construct(width, height); }
 
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
+    /// \brief Resize the graph
+    ///
+    /// Resize the graph. The function will fully destroy and rebuild
+    /// the graph.  This cause that the maps of the graph will
+    /// reallocated automatically and the previous values will be
+    /// lost.
     void resize(int width, int height) {
       Parent::notifier(Arc()).clear();
@@ -604 +610 @@
     }
 
-    /// \brief The column index of the node.
+    /// \brief Gives back the column index of the node.
     ///
     /// Gives back the column index of the node.
@@ -611 +617 @@
     }
 
-    /// \brief The row index of the node.
+    /// \brief Gives back the row index of the node.
     ///
     /// Gives back the row index of the node.
@@ -618 +624 @@
     }
 
-    /// \brief The position of the node.
+    /// \brief Gives back the position of the node.
     ///
     /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair.
@@ -625 +631 @@
     }
 
-    /// \brief The number of the columns.
+    /// \brief Gives back the number of the columns.
     ///
     /// Gives back the number of the columns.
@@ -632 +638 @@
     }
 
-    /// \brief The number of the rows.
+    /// \brief Gives back the number of the rows.
     ///
     /// Gives back the number of the rows.
@@ -639 +645 @@
     }
 
-    /// \brief The arc goes right from the node.
+    /// \brief Gives back the arc goes right from the node.
     ///
     /// Gives back the arc goes right from the node. If there is not
@@ -647 +653 @@
     }
 
-    /// \brief The arc goes left from the node.
+    /// \brief Gives back the arc goes left from the node.
     ///
     /// Gives back the arc goes left from the node. If there is not
@@ -655 +661 @@
     }
 
-    /// \brief The arc goes up from the node.
+    /// \brief Gives back the arc goes up from the node.
     ///
     /// Gives back the arc goes up from the node. If there is not
@@ -663 +669 @@
     }
 
-    /// \brief The arc goes down from the node.
+    /// \brief Gives back the arc goes down from the node.
     ///
     /// Gives back the arc goes down from the node. If there is not

lemon/hypercube_graph.h

@@ -283 +283 @@
   /// \brief Hypercube graph class
   ///
-  /// HypercubeGraph implements a special graph type. The nodes of the
-  /// graph are indexed with integers having at most \c dim binary digits.
+  /// This class implements a special graph type. The nodes of the graph
+  /// are indiced with integers with at most \c dim binary digits.
   /// Two nodes are connected in the graph if and only if their indices
   /// differ only on one position in the binary form.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however 
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
   ///
   /// \note The type of the indices is chosen to \c int for efficiency
   /// reasons. Thus the maximum dimension of this implementation is 26
   /// (assuming that the size of \c int is 32 bit).
+  ///
+  /// This graph type fully conforms to the \ref concepts::Graph
+  /// "Graph concept".
   class HypercubeGraph : public ExtendedHypercubeGraphBase {
     typedef ExtendedHypercubeGraphBase Parent;
@@ -307 +303 @@
     /// Constructs a hypercube graph with \c dim dimensions.
     HypercubeGraph(int dim) { construct(dim); }
-
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
-    void resize(int dim) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      construct(dim);
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
 
     /// \brief The number of dimensions.
@@ -340 +321 @@
     ///
     /// Gives back the dimension id of the given edge.
-    /// It is in the range <tt>[0..dim-1]</tt>.
+    /// It is in the [0..dim-1] range.
     int dimension(Edge edge) const {
       return Parent::dimension(edge);
@@ -348 +329 @@
     ///
     /// Gives back the dimension id of the given arc.
-    /// It is in the range <tt>[0..dim-1]</tt>.
+    /// It is in the [0..dim-1] range.
     int dimension(Arc arc) const {
       return Parent::dimension(arc);

lemon/list_graph.h

@@ -22 +22 @@
 ///\ingroup graphs
 ///\file
-///\brief ListDigraph and ListGraph classes.
+///\brief ListDigraph, ListGraph classes.
 
 #include <lemon/core.h>
@@ -32 +32 @@
 
 namespace lemon {
-
-  class ListDigraph;
 
   class ListDigraphBase {
@@ -65 +63 @@
     class Node {
       friend class ListDigraphBase;
-      friend class ListDigraph;
     protected:
 
@@ -81 +78 @@
     class Arc {
       friend class ListDigraphBase;
-      friend class ListDigraph;
     protected:
 
@@ -121 +117 @@
       int n;
       for(n = first_node;
-          n != -1 && nodes[n].first_out == -1;
+          n!=-1 && nodes[n].first_in == -1;
           n = nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : nodes[n].first_out;
+      arc.id = (n == -1) ? -1 : nodes[n].first_in;
     }
 
     void next(Arc& arc) const {
-      if (arcs[arc.id].next_out != -1) {
-        arc.id = arcs[arc.id].next_out;
+      if (arcs[arc.id].next_in != -1) {
+        arc.id = arcs[arc.id].next_in;
       } else {
         int n;
-        for(n = nodes[arcs[arc.id].source].next;
-            n != -1 && nodes[n].first_out == -1;
+        for(n = nodes[arcs[arc.id].target].next;
+            n!=-1 && nodes[n].first_in == -1;
             n = nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : nodes[n].first_out;
+        arc.id = (n == -1) ? -1 : nodes[n].first_in;
       }
     }
@@ -316 +312 @@
   ///A general directed graph structure.
 
-  ///\ref ListDigraph is a versatile and fast directed graph
-  ///implementation based on linked lists that are stored in
+  ///\ref ListDigraph is a simple and fast <em>directed graph</em>
+  ///implementation based on static linked lists that are stored in
   ///\c std::vector structures.
   ///
-  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
+  ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
+  ///also provides several useful additional functionalities.
+  ///Most of the member functions and nested classes are documented
   ///only in the concept class.
   ///
   ///\sa concepts::Digraph
-  ///\sa ListGraph
+
   class ListDigraph : public ExtendedListDigraphBase {
     typedef ExtendedListDigraphBase Parent;
 
   private:
-    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
+    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
+
+    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
+    ///
     ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
-    /// \brief Assignment of a digraph to another one is \e not allowed.
-    /// Use DigraphCopy instead.
+    ///\brief Assignment of ListDigraph to another one is \e not allowed.
+    ///Use copyDigraph() instead.
+
+    ///Assignment of ListDigraph to another one is \e not allowed.
+    ///Use copyDigraph() instead.
     void operator=(const ListDigraph &) {}
   public:
@@ -346 +348 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
+    ///Add a new node to the digraph.
     ///\return The new node.
     Node addNode() { return Parent::addNode(); }
@@ -352 +354 @@
     ///Add a new arc to the digraph.
 
-    ///This function adds a new arc to the digraph with source node \c s
+    ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return The new arc.
-    Arc addArc(Node s, Node t) {
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
@@ -361 +363 @@
     ///\brief Erase a node from the digraph.
     ///
-    ///This function erases the given node from the digraph.
-    void erase(Node n) { Parent::erase(n); }
+    ///Erase a node from the digraph.
+    ///
+    void erase(const Node& n) { Parent::erase(n); }
 
     ///\brief Erase an arc from the digraph.
     ///
-    ///This function erases the given arc from the digraph.
-    void erase(Arc a) { Parent::erase(a); }
+    ///Erase an arc from the digraph.
+    ///
+    void erase(const Arc& a) { Parent::erase(a); }
 
     /// Node validity check
 
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the digraph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
-    /// added to the digraph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
+    ///
+    /// \warning A Node pointing to a removed item
+    /// could become valid again later if new nodes are
+    /// added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
     /// Arc validity check
 
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the digraph.
-    ///
-    /// \warning A removed arc could become valid again if new arcs are
-    /// added to the digraph.
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning An Arc pointing to a removed item
+    /// could become valid again later if new nodes are
+    /// added to the graph.
     bool valid(Arc a) const { return Parent::valid(a); }
 
-    /// Change the target node of an arc
-
-    /// This function changes the target node of the given arc \c a to \c n.
-    ///
-    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
-    ///arc remain valid, however \c InArcIt iterators are invalidated.
+    /// Change the target of \c a to \c n
+
+    /// Change the target of \c a to \c n
+    ///
+    ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
+    ///the changed arc remain valid. However <tt>InArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
@@ -399 +406 @@
       Parent::changeTarget(a,n);
     }
-    /// Change the source node of an arc
-
-    /// This function changes the source node of the given arc \c a to \c n.
-    ///
-    ///\note \c InArcIt iterators referencing the changed arc remain
-    ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
+    /// Change the source of \c a to \c n
+
+    /// Change the source of \c a to \c n
+    ///
+    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
+    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
@@ -412 +420 @@
     }
 
-    /// Reverse the direction of an arc.
-
-    /// This function reverses the direction of the given arc.
-    ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing
-    ///the changed arc are invalidated.
+    /// Invert the direction of an arc.
+
+    ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
+    ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
-    void reverseArc(Arc a) {
-      Node t=target(a);
-      changeTarget(a,source(a));
-      changeSource(a,t);
-    }
+    void reverseArc(Arc e) {
+      Node t=target(e);
+      changeTarget(e,source(e));
+      changeSource(e,t);
+    }
+
+    /// Reserve memory for nodes.
+
+    /// Using this function it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveArc
+    void reserveNode(int n) { nodes.reserve(n); };
+
+    /// Reserve memory for arcs.
+
+    /// Using this function it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveNode
+    void reserveArc(int m) { arcs.reserve(m); };
 
     ///Contract two nodes.
 
-    ///This function contracts the given two nodes.
-    ///Node \c v is removed, but instead of deleting its
-    ///incident arcs, they are joined to node \c u.
-    ///If the last parameter \c r is \c true (this is the default value),
-    ///then the newly created loops are removed.
-    ///
-    ///\note The moved arcs are joined to node \c u using changeSource()
-    ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
-    ///invalidated for the outgoing arcs of node \c v and \c InArcIt
-    ///iterators are invalidated for the incomming arcs of \c v.
-    ///Moreover all iterators referencing node \c v or the removed 
-    ///loops are also invalidated. Other iterators remain valid.
+    ///This function contracts two nodes.
+    ///Node \p b will be removed but instead of deleting
+    ///incident arcs, they will be joined to \p a.
+    ///The last parameter \p r controls whether to remove loops. \c true
+    ///means that loops will be removed.
+    ///
+    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
+    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
+    ///may be invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
-    void contract(Node u, Node v, bool r = true)
+    void contract(Node a, Node b, bool r = true)
     {
-      for(OutArcIt e(*this,v);e!=INVALID;) {
+      for(OutArcIt e(*this,b);e!=INVALID;) {
         OutArcIt f=e;
         ++f;
-        if(r && target(e)==u) erase(e);
-        else changeSource(e,u);
+        if(r && target(e)==a) erase(e);
+        else changeSource(e,a);
         e=f;
       }
-      for(InArcIt e(*this,v);e!=INVALID;) {
+      for(InArcIt e(*this,b);e!=INVALID;) {
         InArcIt f=e;
         ++f;
-        if(r && source(e)==u) erase(e);
-        else changeTarget(e,u);
+        if(r && source(e)==a) erase(e);
+        else changeTarget(e,a);
         e=f;
       }
-      erase(v);
+      erase(b);
     }
 
     ///Split a node.
 
-    ///This function splits the given node. First, a new node is added
-    ///to the digraph, then the source of each outgoing arc of node \c n
-    ///is moved to this new node.
-    ///If the second parameter \c connect is \c true (this is the default
-    ///value), then a new arc from node \c n to the newly created node
-    ///is also added.
+    ///This function splits a node. First a new node is added to the digraph,
+    ///then the source of each outgoing arc of \c n is moved to this new node.
+    ///If \c connect is \c true (this is the default value), then a new arc
+    ///from \c n to the newly created node is also added.
     ///\return The newly created node.
     ///
-    ///\note All iterators remain valid.
-    ///
-    ///\warning This functionality cannot be used together with the
+    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
+    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
+    ///be invalidated.
+    ///
+    ///\warning This functionality cannot be used in conjunction with the
     ///Snapshot feature.
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      nodes[b.id].first_out=nodes[n.id].first_out;
-      nodes[n.id].first_out=-1;
-      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
-        arcs[i].source=b.id;
+      for(OutArcIt e(*this,n);e!=INVALID;) {
+        OutArcIt f=e;
+        ++f;
+        changeSource(e,b);
+        e=f;
       }
       if (connect) addArc(n,b);
@@ -489 +515 @@
     ///Split an arc.
 
-    ///This function splits the given arc. First, a new node \c v is
-    ///added to the digraph, then the target node of the original arc
-    ///is set to \c v. Finally, an arc from \c v to the original target
-    ///is added.
+    ///This function splits an arc. First a new node \c b is added to
+    ///the digraph, then the original arc is re-targeted to \c
+    ///b. Finally an arc from \c b to the original target is added.
+    ///
     ///\return The newly created node.
-    ///
-    ///\note \c InArcIt iterators referencing the original arc are
-    ///invalidated. Other iterators remain valid.
     ///
     ///\warning This functionality cannot be used together with the
     ///Snapshot feature.
-    Node split(Arc a) {
-      Node v = addNode();
-      addArc(v,target(a));
-      changeTarget(a,v);
-      return v;
-    }
-
-    ///Clear the digraph.
-
-    ///This function erases all nodes and arcs from the digraph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for arcs.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
+    Node split(Arc e) {
+      Node b = addNode();
+      addArc(b,target(e));
+      changeTarget(e,b);
+      return b;
+    }
 
     /// \brief Class to make a snapshot of the digraph and restore
@@ -543 +538 @@
     /// restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state, 
-    /// i.e. you cannot add the removed nodes and arcs again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and arc deletions and other modifications (e.g.
-    /// reversing, contracting, splitting arcs or nodes) cannot be
+    /// \warning Arc and node deletions and other modifications (e.g.
+    /// contracting, splitting, reversing arcs or nodes) cannot be
     /// restored. These events invalidate the snapshot.
-    /// However the arcs and nodes that were added to the digraph after
-    /// making the current snapshot can be removed without invalidating it.
     class Snapshot {
     protected:
@@ -721 +710 @@
       ///
       /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
+      /// To actually make a snapshot you must call save().
       Snapshot()
         : digraph(0), node_observer_proxy(*this),
@@ -728 +717 @@
       /// \brief Constructor that immediately makes a snapshot.
       ///
-      /// This constructor immediately makes a snapshot of the given digraph.
-      Snapshot(ListDigraph &gr)
+      /// This constructor immediately makes a snapshot of the digraph.
+      /// \param _digraph The digraph we make a snapshot of.
+      Snapshot(ListDigraph &_digraph)
         : node_observer_proxy(*this),
           arc_observer_proxy(*this) {
-        attach(gr);
+        attach(_digraph);
       }
 
       /// \brief Make a snapshot.
       ///
-      /// This function makes a snapshot of the given digraph.
-      /// It can be called more than once. In case of a repeated
+      /// Make a snapshot of the digraph.
+      ///
+      /// This function can be called more than once. In case of a repeated
       /// call, the previous snapshot gets lost.
-      void save(ListDigraph &gr) {
+      /// \param _digraph The digraph we make the snapshot of.
+      void save(ListDigraph &_digraph) {
         if (attached()) {
           detach();
           clear();
         }
-        attach(gr);
+        attach(_digraph);
       }
 
       /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListDigraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
+      //
+      /// Undo the changes until the last snapshot created by save().
       void restore() {
         detach();
@@ -768 +756 @@
       }
 
-      /// \brief Returns \c true if the snapshot is valid.
+      /// \brief Gives back true when the snapshot is valid.
       ///
-      /// This function returns \c true if the snapshot is valid.
+      /// Gives back true when the snapshot is valid.
       bool valid() const {
         return attached();
@@ -807 +795 @@
 
     typedef ListGraphBase Graph;
+
+    class Node;
+    class Arc;
+    class Edge;
 
     class Node {
@@ -856 +848 @@
       bool operator<(const Arc& arc) const {return id < arc.id;}
     };
+
+
 
     ListGraphBase()
@@ -1171 +1165 @@
   ///A general undirected graph structure.
 
-  ///\ref ListGraph is a versatile and fast undirected graph
-  ///implementation based on linked lists that are stored in
+  ///\ref ListGraph is a simple and fast <em>undirected graph</em>
+  ///implementation based on static linked lists that are stored in
   ///\c std::vector structures.
   ///
-  ///This type fully conforms to the \ref concepts::Graph "Graph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
+  ///It conforms to the \ref concepts::Graph "Graph concept" and it
+  ///also provides several useful additional functionalities.
+  ///Most of the member functions and nested classes are documented
   ///only in the concept class.
   ///
   ///\sa concepts::Graph
-  ///\sa ListDigraph
+
   class ListGraph : public ExtendedListGraphBase {
     typedef ExtendedListGraphBase Parent;
 
   private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
+
+    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
+    ///
     ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
+    ///\brief Assignment of ListGraph to another one is \e not allowed.
+    ///Use copyGraph() instead.
+
+    ///Assignment of ListGraph to another one is \e not allowed.
+    ///Use copyGraph() instead.
     void operator=(const ListGraph &) {}
   public:
@@ -1202 +1202 @@
     /// \brief Add a new node to the graph.
     ///
-    /// This function adds a new node to the graph.
+    /// Add a new node to the graph.
     /// \return The new node.
     Node addNode() { return Parent::addNode(); }
@@ -1208 +1208 @@
     /// \brief Add a new edge to the graph.
     ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
+    /// Add a new edge to the graph with source node \c s
+    /// and target node \c t.
     /// \return The new edge.
-    Edge addEdge(Node u, Node v) {
-      return Parent::addEdge(u, v);
-    }
-
-    ///\brief Erase a node from the graph.
-    ///
-    /// This function erases the given node from the graph.
-    void erase(Node n) { Parent::erase(n); }
-
-    ///\brief Erase an edge from the graph.
-    ///
-    /// This function erases the given edge from the graph.
-    void erase(Edge e) { Parent::erase(e); }
+    Edge addEdge(const Node& s, const Node& t) {
+      return Parent::addEdge(s, t);
+    }
+
+    /// \brief Erase a node from the graph.
+    ///
+    /// Erase a node from the graph.
+    ///
+    void erase(const Node& n) { Parent::erase(n); }
+
+    /// \brief Erase an edge from the graph.
+    ///
+    /// Erase an edge from the graph.
+    ///
+    void erase(const Edge& e) { Parent::erase(e); }
     /// Node validity check
 
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
+    ///
+    /// \warning A Node pointing to a removed item
+    /// could become valid again later if new nodes are
     /// added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
+    /// Arc validity check
+
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning An Arc pointing to a removed item
+    /// could become valid again later if new edges are
+    /// added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
     /// Edge validity check
 
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge could become valid again if new edges are
+    /// This function gives back true if the given edge is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning A Edge pointing to a removed item
+    /// could become valid again later if new edges are
     /// added to the graph.
     bool valid(Edge e) const { return Parent::valid(e); }
-    /// Arc validity check
-
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    /// \brief Change the first node of an edge.
-    ///
-    /// This function changes the first node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt and \c ArcIt iterators referencing the
-    ///changed edge are invalidated and all other iterators whose
-    ///base node is the changed node are also invalidated.
+    /// \brief Change the end \c u of \c e to \c n
+    ///
+    /// This function changes the end \c u of \c e to node \c n.
+    ///
+    ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the
+    ///changed edge are invalidated and if the changed node is the
+    ///base node of an iterator then this iterator is also
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1263 +1267 @@
       Parent::changeU(e,n);
     }
-    /// \brief Change the second node of an edge.
-    ///
-    /// This function changes the second node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, however \c ArcIt iterators referencing the changed edge and
-    ///all other iterators whose base node is the changed node are also
-    ///invalidated.
+    /// \brief Change the end \c v of \c e to \c n
+    ///
+    /// This function changes the end \c v of \c e to \c n.
+    ///
+    ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain
+    ///valid, however <tt>ArcIt</tt>s and if the changed node is the
+    ///base node of an iterator then this iterator is invalidated.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1277 +1280 @@
       Parent::changeV(e,n);
     }
-
     /// \brief Contract two nodes.
     ///
-    /// This function contracts the given two nodes.
-    /// Node \c b is removed, but instead of deleting
-    /// its incident edges, they are joined to node \c a.
-    /// If the last parameter \c r is \c true (this is the default value),
-    /// then the newly created loops are removed.
-    ///
-    /// \note The moved edges are joined to node \c a using changeU()
-    /// or changeV(), thus all edge and arc iterators whose base node is
-    /// \c b are invalidated.
-    /// Moreover all iterators referencing node \c b or the removed 
-    /// loops are also invalidated. Other iterators remain valid.
+    /// This function contracts two nodes.
+    /// Node \p b will be removed but instead of deleting
+    /// its neighboring arcs, they will be joined to \p a.
+    /// The last parameter \p r controls whether to remove loops. \c true
+    /// means that loops will be removed.
+    ///
+    /// \note The <tt>ArcIt</tt>s referencing a moved arc remain
+    /// valid.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1309 +1308 @@
     }
 
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -1345 +1317 @@
     /// using the restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state, 
-    /// i.e. you cannot add the removed nodes and edges again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and edge deletions and other modifications
-    /// (e.g. changing the end-nodes of edges or contracting nodes)
-    /// cannot be restored. These events invalidate the snapshot.
-    /// However the edges and nodes that were added to the graph after
-    /// making the current snapshot can be removed without invalidating it.
+    /// \warning Edge and node deletions and other modifications
+    /// (e.g. changing nodes of edges, contracting nodes) cannot be
+    /// restored. These events invalidate the snapshot.
     class Snapshot {
     protected:
@@ -1523 +1489 @@
       ///
       /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
+      /// To actually make a snapshot you must call save().
       Snapshot()
         : graph(0), node_observer_proxy(*this),
@@ -1530 +1496 @@
       /// \brief Constructor that immediately makes a snapshot.
       ///
-      /// This constructor immediately makes a snapshot of the given graph.
-      Snapshot(ListGraph &gr)
+      /// This constructor immediately makes a snapshot of the graph.
+      /// \param _graph The graph we make a snapshot of.
+      Snapshot(ListGraph &_graph)
         : node_observer_proxy(*this),
           edge_observer_proxy(*this) {
-        attach(gr);
+        attach(_graph);
       }
 
       /// \brief Make a snapshot.
       ///
-      /// This function makes a snapshot of the given graph.
-      /// It can be called more than once. In case of a repeated
+      /// Make a snapshot of the graph.
+      ///
+      /// This function can be called more than once. In case of a repeated
       /// call, the previous snapshot gets lost.
-      void save(ListGraph &gr) {
+      /// \param _graph The graph we make the snapshot of.
+      void save(ListGraph &_graph) {
         if (attached()) {
           detach();
           clear();
         }
-        attach(gr);
+        attach(_graph);
       }
 
       /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListGraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
+      //
+      /// Undo the changes until the last snapshot created by save().
       void restore() {
         detach();
@@ -1570 +1535 @@
       }
 
-      /// \brief Returns \c true if the snapshot is valid.
+      /// \brief Gives back true when the snapshot is valid.
       ///
-      /// This function returns \c true if the snapshot is valid.
+      /// Gives back true when the snapshot is valid.
       bool valid() const {
         return attached();

lemon/lp_base.h

@@ -944 +944 @@
     virtual int _addRow() = 0;
 
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-      int row = _addRow();
-      _setRowCoeffs(row, b, e);
-      _setRowLowerBound(row, l);
-      _setRowUpperBound(row, u);
-      return row;
-    }
-
     virtual void _eraseCol(int col) = 0;
     virtual void _eraseRow(int row) = 0;
@@ -1216 +1208 @@
     ///\return The created row.
     Row addRow(Value l,const Expr &e, Value u) {
-      Row r;
-      e.simplify();
-      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
-                                ExprIterator(e.comps.end(), cols), u - *e));
+      Row r=addRow();
+      row(r,l,e,u);
       return r;
     }
@@ -1228 +1218 @@
     ///\return The created row.
     Row addRow(const Constr &c) {
-      Row r;
-      c.expr().simplify();
-      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF, 
-                                ExprIterator(c.expr().comps.begin(), cols),
-                                ExprIterator(c.expr().comps.end(), cols),
-                                c.upperBounded()?c.upperBound():INF));
+      Row r=addRow();
+      row(r,c);
       return r;
     }

lemon/lp_skeleton.cc

@@ -29 +29 @@
 
   int SkeletonSolverBase::_addRow()
-  {
-    return ++row_num;
-  }
-
-  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
   {
     return ++row_num;

lemon/lp_skeleton.h

@@ -45 +45 @@
     /// \e
     virtual int _addRow();
-    /// \e
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
     /// \e
     virtual void _eraseCol(int i);

lemon/maps.h

@@ -23 +23 @@
 #include <functional>
 #include <vector>
-#include <map>
 
 #include <lemon/core.h>
@@ -30 +29 @@
 ///\ingroup maps
 ///\brief Miscellaneous property maps
+
+#include <map>
 
 namespace lemon {
@@ -57 +58 @@
   /// but data written to it is not required (i.e. it will be sent to
   /// <tt>/dev/null</tt>).
-  /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   ///
   /// \sa ConstMap
@@ -90 +91 @@
   ///
   /// In other aspects it is equivalent to \c NullMap.
-  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
@@ -159 +160 @@
   ///
   /// In other aspects it is equivalent to \c NullMap.
-  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
@@ -233 +234 @@
   /// It can be used with some data structures, for example
   /// \c UnionFind, \c BinHeap, when the used items are small
-  /// integers. This map conforms to the \ref concepts::ReferenceMap
+  /// integers. This map conforms the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
   ///
@@ -341 +342 @@
   /// stored actually. This value can be different from the default
   /// contructed value (i.e. \c %Value()).
-  /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap"
+  /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
   /// concept.
   ///
@@ -707 +708 @@
   /// The \c Key type of it is inherited from \c M and the \c Value
   /// type is \c V.
-  /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+  /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
   ///
   /// The simplest way of using this map is through the convertMap()
@@ -1790 +1791 @@
   /// \code
   ///   std::vector<Node> v;
-  ///   dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);
+  ///   dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();
   /// \endcode
   /// \code
   ///   std::vector<Node> v(countNodes(g));
-  ///   dfs(g).processedMap(loggerBoolMap(v.begin())).run(s);
+  ///   dfs(g,s).processedMap(loggerBoolMap(v.begin())).run();
   /// \endcode
   ///
@@ -1818 +1819 @@
   ///
   /// IdMap provides a unique and immutable id for each item of the
-  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
+  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 
   ///  - \b unique: different items get different ids,
   ///  - \b immutable: the id of an item does not change (even if you
@@ -1826 +1827 @@
   /// the items stored in the graph, which is returned by the \c id()
   /// function of the graph. This map can be inverted with its member
-  /// class \c InverseMap or with the \c operator()() member.
+  /// class \c InverseMap or with the \c operator() member.
   ///
   /// \tparam GR The graph type.
@@ -1866 +1867 @@
   public:
 
-    /// \brief The inverse map type of IdMap.
-    ///
-    /// The inverse map type of IdMap. The subscript operator gives back
-    /// an item by its id.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+    /// \brief This class represents the inverse of its owner (IdMap).
+    ///
+    /// This class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
@@ -1885 +1884 @@
       explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 
-      /// \brief Gives back an item by its id.
+      /// \brief Gives back the given item from its id.
       ///
-      /// Gives back an item by its id.
+      /// Gives back the given item from its id.
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 
@@ -1900 +1899 @@
   };
 
-  /// \brief Returns an \c IdMap class.
-  ///
-  /// This function just returns an \c IdMap class.
-  /// \relates IdMap
-  template <typename K, typename GR>
-  inline IdMap<GR, K> idMap(const GR& graph) {
-    return IdMap<GR, K>(graph);
-  }
 
   /// \brief General cross reference graph map type.
@@ -1914 +1905 @@
   /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
   /// and if a key is set to a new value, then stores it in the inverse map.
-  /// The graph items can be accessed by their values either using
-  /// \c InverseMap or \c operator()(), and the values of the map can be
-  /// accessed with an STL compatible forward iterator (\c ValueIt).
-  /// 
-  /// This map is intended to be used when all associated values are
-  /// different (the map is actually invertable) or there are only a few
-  /// items with the same value.
-  /// Otherwise consider to use \c IterableValueMap, which is more 
-  /// suitable and more efficient for such cases. It provides iterators
-  /// to traverse the items with the same associated value, however
-  /// it does not have \c InverseMap.
+  /// The values of the map can be accessed
+  /// with stl compatible forward iterator.
   ///
   /// This type is not reference map, so it cannot be modified with
@@ -1965 +1947 @@
     /// \brief Forward iterator for values.
     ///
-    /// This iterator is an STL compatible forward
+    /// This iterator is an stl compatible forward
     /// iterator on the values of the map. The values can
     /// be accessed in the <tt>[beginValue, endValue)</tt> range.
     /// They are considered with multiplicity, so each value is
     /// traversed for each item it is assigned to.
-    class ValueIt
+    class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
       friend class CrossRefMap;
     private:
-      ValueIt(typename Container::const_iterator _it)
+      ValueIterator(typename Container::const_iterator _it)
         : it(_it) {}
     public:
 
-      /// Constructor
-      ValueIt() {}
-
-      /// \e
-      ValueIt& operator++() { ++it; return *this; }
-      /// \e
-      ValueIt operator++(int) {
-        ValueIt tmp(*this);
+      ValueIterator() {}
+
+      ValueIterator& operator++() { ++it; return *this; }
+      ValueIterator operator++(int) {
+        ValueIterator tmp(*this);
         operator++();
         return tmp;
       }
 
-      /// \e
       const Value& operator*() const { return it->first; }
-      /// \e
       const Value* operator->() const { return &(it->first); }
 
-      /// \e
-      bool operator==(ValueIt jt) const { return it == jt.it; }
-      /// \e
-      bool operator!=(ValueIt jt) const { return it != jt.it; }
+      bool operator==(ValueIterator jt) const { return it == jt.it; }
+      bool operator!=(ValueIterator jt) const { return it != jt.it; }
 
     private:
       typename Container::const_iterator it;
     };
-    
-    /// Alias for \c ValueIt
-    typedef ValueIt ValueIterator;
 
     /// \brief Returns an iterator to the first value.
     ///
-    /// Returns an STL compatible iterator to the
+    /// Returns an stl compatible iterator to the
     /// first value of the map. The values of the
     /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
-    ValueIt beginValue() const {
-      return ValueIt(_inv_map.begin());
+    ValueIterator beginValue() const {
+      return ValueIterator(_inv_map.begin());
     }
 
     /// \brief Returns an iterator after the last value.
     ///
-    /// Returns an STL compatible iterator after the
+    /// Returns an stl compatible iterator after the
     /// last value of the map. The values of the
     /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
-    ValueIt endValue() const {
-      return ValueIt(_inv_map.end());
+    ValueIterator endValue() const {
+      return ValueIterator(_inv_map.end());
     }
 
@@ -2061 +2033 @@
       typename Container::const_iterator it = _inv_map.find(val);
       return it != _inv_map.end() ? it->second : INVALID;
-    }
-    
-    /// \brief Returns the number of items with the given value.
-    ///
-    /// This function returns the number of items with the given value
-    /// associated with it.
-    int count(const Value &val) const {
-      return _inv_map.count(val);
     }
 
@@ -2120 +2084 @@
   public:
 
-    /// \brief The inverse map type of CrossRefMap.
-    ///
-    /// The inverse map type of CrossRefMap. The subscript operator gives
-    /// back an item by its value.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
-    /// \see inverse()
+    /// \brief The inverse map type.
+    ///
+    /// The inverse of this map. The subscript operator of the map
+    /// gives back the item that was last assigned to the value.
     class InverseMap {
     public:
@@ -2152 +2114 @@
     };
 
-    /// \brief Gives back the inverse of the map.
-    ///
-    /// Gives back the inverse of the CrossRefMap.
+    /// \brief It gives back the read-only inverse map.
+    ///
+    /// It gives back the read-only inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
@@ -2161 +2123 @@
   };
 
-  /// \brief Provides continuous and unique id for the
+  /// \brief Provides continuous and unique ID for the
   /// items of a graph.
   ///
   /// RangeIdMap provides a unique and continuous
-  /// id for each item of a given type (\c Node, \c Arc or
+  /// ID for each item of a given type (\c Node, \c Arc or
   /// \c Edge) in a graph. This id is
   ///  - \b unique: different items get different ids,
@@ -2176 +2138 @@
   /// the \c id() function of the graph or \ref IdMap.
   /// This map can be inverted with its member class \c InverseMap,
-  /// or with the \c operator()() member.
+  /// or with the \c operator() member.
   ///
   /// \tparam GR The graph type.
@@ -2304 +2266 @@
     }
 
-    /// \brief Gives back the \e range \e id of the item
-    ///
-    /// Gives back the \e range \e id of the item.
+    /// \brief Gives back the \e RangeId of the item
+    ///
+    /// Gives back the \e RangeId of the item.
     int operator[](const Item& item) const {
       return Map::operator[](item);
     }
 
-    /// \brief Gives back the item belonging to a \e range \e id
-    ///
-    /// Gives back the item belonging to the given \e range \e id.
+    /// \brief Gives back the item belonging to a \e RangeId
+    /// 
+    /// Gives back the item belonging to a \e RangeId.
     Item operator()(int id) const {
       return _inv_map[id];
@@ -2327 +2289 @@
     /// \brief The inverse map type of RangeIdMap.
     ///
-    /// The inverse map type of RangeIdMap. The subscript operator gives
-    /// back an item by its \e range \e id.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+    /// The inverse map type of RangeIdMap.
     class InverseMap {
     public:
@@ -2347 +2307 @@
       ///
       /// Subscript operator. It gives back the item
-      /// that the given \e range \e id currently belongs to.
+      /// that the descriptor currently belongs to.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2365 +2325 @@
     /// \brief Gives back the inverse of the map.
     ///
-    /// Gives back the inverse of the RangeIdMap.
+    /// Gives back the inverse of the map.
     const InverseMap inverse() const {
       return InverseMap(*this);
     }
-  };
-
-  /// \brief Returns a \c RangeIdMap class.
-  ///
-  /// This function just returns an \c RangeIdMap class.
-  /// \relates RangeIdMap
-  template <typename K, typename GR>
-  inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
-    return RangeIdMap<GR, K>(graph);
-  }
-  
-  /// \brief Dynamic iterable \c bool map.
-  ///
-  /// This class provides a special graph map type which can store a
-  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
-  /// For both \c true and \c false values it is possible to iterate on
-  /// the keys mapped to the value.
-  ///
-  /// This type is a reference map, so it can be modified with the
-  /// subscript operator.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IterableIntMap, IterableValueMap
-  /// \see CrossRefMap
-  template <typename GR, typename K>
-  class IterableBoolMap
-    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
-  private:
-    typedef GR Graph;
-
-    typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;
-    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;
-
-    std::vector<K> _array;
-    int _sep;
-
-  public:
-
-    /// Indicates that the map is reference map.
-    typedef True ReferenceMapTag;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef bool Value;
-    /// The const reference type.
-    typedef const Value& ConstReference;
-
-  private:
-
-    int position(const Key& key) const {
-      return Parent::operator[](key);
-    }
-
-  public:
-
-    /// \brief Reference to the value of the map.
-    ///
-    /// This class is similar to the \c bool type. It can be converted to
-    /// \c bool and it provides the same operators.
-    class Reference {
-      friend class IterableBoolMap;
-    private:
-      Reference(IterableBoolMap& map, const Key& key)
-        : _key(key), _map(map) {}
-    public:
-
-      Reference& operator=(const Reference& value) {
-        _map.set(_key, static_cast<bool>(value));
-         return *this;
-      }
-
-      operator bool() const {
-        return static_cast<const IterableBoolMap&>(_map)[_key];
-      }
-
-      Reference& operator=(bool value) {
-        _map.set(_key, value);
-        return *this;
-      }
-      Reference& operator&=(bool value) {
-        _map.set(_key, _map[_key] & value);
-        return *this;
-      }
-      Reference& operator|=(bool value) {
-        _map.set(_key, _map[_key] | value);
-        return *this;
-      }
-      Reference& operator^=(bool value) {
-        _map.set(_key, _map[_key] ^ value);
-        return *this;
-      }
-    private:
-      Key _key;
-      IterableBoolMap& _map;
-    };
-
-    /// \brief Constructor of the map with a default value.
-    ///
-    /// Constructor of the map with a default value.
-    explicit IterableBoolMap(const Graph& graph, bool def = false)
-      : Parent(graph) {
-      typename Parent::Notifier* nf = Parent::notifier();
-      Key it;
-      for (nf->first(it); it != INVALID; nf->next(it)) {
-        Parent::set(it, _array.size());
-        _array.push_back(it);
-      }
-      _sep = (def ? _array.size() : 0);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    bool operator[](const Key& key) const {
-      return position(key) < _sep;
-    }
-
-    /// \brief Subscript operator of the map.
-    ///
-    /// Subscript operator of the map.
-    Reference operator[](const Key& key) {
-      return Reference(*this, key);
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, bool value) {
-      int pos = position(key);
-      if (value) {
-        if (pos < _sep) return;
-        Key tmp = _array[_sep];
-        _array[_sep] = key;
-        Parent::set(key, _sep);
-        _array[pos] = tmp;
-        Parent::set(tmp, pos);
-        ++_sep;
-      } else {
-        if (pos >= _sep) return;
-        --_sep;
-        Key tmp = _array[_sep];
-        _array[_sep] = key;
-        Parent::set(key, _sep);
-        _array[pos] = tmp;
-        Parent::set(tmp, pos);
-      }
-    }
-
-    /// \brief Set all items.
-    ///
-    /// Set all items in the map.
-    /// \note Constant time operation.
-    void setAll(bool value) {
-      _sep = (value ? _array.size() : 0);
-    }
-
-    /// \brief Returns the number of the keys mapped to \c true.
-    ///
-    /// Returns the number of the keys mapped to \c true.
-    int trueNum() const {
-      return _sep;
-    }
-
-    /// \brief Returns the number of the keys mapped to \c false.
-    ///
-    /// Returns the number of the keys mapped to \c false.
-    int falseNum() const {
-      return _array.size() - _sep;
-    }
-
-    /// \brief Iterator for the keys mapped to \c true.
-    ///
-    /// Iterator for the keys mapped to \c true. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class TrueIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator.
-      ///
-      /// Creates an iterator. It iterates on the
-      /// keys mapped to \c true.
-      /// \param map The IterableBoolMap.
-      explicit TrueIt(const IterableBoolMap& map)
-        : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),
-          _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      TrueIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      TrueIt& operator++() {
-        int pos = _map->position(*this);
-        Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-    /// \brief Iterator for the keys mapped to \c false.
-    ///
-    /// Iterator for the keys mapped to \c false. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class FalseIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator.
-      ///
-      /// Creates an iterator. It iterates on the
-      /// keys mapped to \c false.
-      /// \param map The IterableBoolMap.
-      explicit FalseIt(const IterableBoolMap& map)
-        : Parent(map._sep < int(map._array.size()) ?
-                 map._array.back() : INVALID), _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      FalseIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      FalseIt& operator++() {
-        int pos = _map->position(*this);
-        Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-    /// \brief Iterator for the keys mapped to a given value.
-    ///
-    /// Iterator for the keys mapped to a given value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys mapped to the given value.
-      /// \param map The IterableBoolMap.
-      /// \param value The value.
-      ItemIt(const IterableBoolMap& map, bool value)
-        : Parent(value ? 
-                 (map._sep > 0 ?
-                  map._array[map._sep - 1] : INVALID) :
-                 (map._sep < int(map._array.size()) ?
-                  map._array.back() : INVALID)), _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ItemIt& operator++() {
-        int pos = _map->position(*this);
-        int _sep = pos >= _map->_sep ? _map->_sep : 0;
-        Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-  protected:
-
-    virtual void add(const Key& key) {
-      Parent::add(key);
-      Parent::set(key, _array.size());
-      _array.push_back(key);
-    }
-
-    virtual void add(const std::vector<Key>& keys) {
-      Parent::add(keys);
-      for (int i = 0; i < int(keys.size()); ++i) {
-        Parent::set(keys[i], _array.size());
-        _array.push_back(keys[i]);
-      }
-    }
-
-    virtual void erase(const Key& key) {
-      int pos = position(key);
-      if (pos < _sep) {
-        --_sep;
-        Parent::set(_array[_sep], pos);
-        _array[pos] = _array[_sep];
-        Parent::set(_array.back(), _sep);
-        _array[_sep] = _array.back();
-        _array.pop_back();
-      } else {
-        Parent::set(_array.back(), pos);
-        _array[pos] = _array.back();
-        _array.pop_back();
-      }
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        int pos = position(keys[i]);
-        if (pos < _sep) {
-          --_sep;
-          Parent::set(_array[_sep], pos);
-          _array[pos] = _array[_sep];
-          Parent::set(_array.back(), _sep);
-          _array[_sep] = _array.back();
-          _array.pop_back();
-        } else {
-          Parent::set(_array.back(), pos);
-          _array[pos] = _array.back();
-          _array.pop_back();
-        }
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void build() {
-      Parent::build();
-      typename Parent::Notifier* nf = Parent::notifier();
-      Key it;
-      for (nf->first(it); it != INVALID; nf->next(it)) {
-        Parent::set(it, _array.size());
-        _array.push_back(it);
-      }
-      _sep = 0;
-    }
-
-    virtual void clear() {
-      _array.clear();
-      _sep = 0;
-      Parent::clear();
-    }
-
-  };
-
-
-  namespace _maps_bits {
-    template <typename Item>
-    struct IterableIntMapNode {
-      IterableIntMapNode() : value(-1) {}
-      IterableIntMapNode(int _value) : value(_value) {}
-      Item prev, next;
-      int value;
-    };
-  }
-
-  /// \brief Dynamic iterable integer map.
-  ///
-  /// This class provides a special graph map type which can store an
-  /// integer value for graph items (\c Node, \c Arc or \c Edge).
-  /// For each non-negative value it is possible to iterate on the keys
-  /// mapped to the value.
-  ///
-  /// This map is intended to be used with small integer values, for which
-  /// it is efficient, and supports iteration only for non-negative values.
-  /// If you need large values and/or iteration for negative integers,
-  /// consider to use \ref IterableValueMap instead.
-  ///
-  /// This type is a reference map, so it can be modified with the
-  /// subscript operator.
-  ///
-  /// \note The size of the data structure depends on the largest
-  /// value in the map.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IterableBoolMap, IterableValueMap
-  /// \see CrossRefMap
-  template <typename GR, typename K>
-  class IterableIntMap
-    : protected ItemSetTraits<GR, K>::
-        template Map<_maps_bits::IterableIntMapNode<K> >::Type {
-  public:
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef int Value;
-    /// The graph type
-    typedef GR Graph;
-
-    /// \brief Constructor of the map.
-    ///
-    /// Constructor of the map. It sets all values to -1.
-    explicit IterableIntMap(const Graph& graph)
-      : Parent(graph) {}
-
-    /// \brief Constructor of the map with a given value.
-    ///
-    /// Constructor of the map with a given value.
-    explicit IterableIntMap(const Graph& graph, int value)
-      : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {
-      if (value >= 0) {
-        for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-          lace(it);
-        }
-      }
-    }
-
-  private:
-
-    void unlace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.value < 0) return;
-      if (node.prev != INVALID) {
-        Parent::operator[](node.prev).next = node.next;
-      } else {
-        _first[node.value] = node.next;
-      }
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = node.prev;
-      }
-      while (!_first.empty() && _first.back() == INVALID) {
-        _first.pop_back();
-      }
-    }
-
-    void lace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.value < 0) return;
-      if (node.value >= int(_first.size())) {
-        _first.resize(node.value + 1, INVALID);
-      }
-      node.prev = INVALID;
-      node.next = _first[node.value];
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = key;
-      }
-      _first[node.value] = key;
-    }
-
-  public:
-
-    /// Indicates that the map is reference map.
-    typedef True ReferenceMapTag;
-
-    /// \brief Reference to the value of the map.
-    ///
-    /// This class is similar to the \c int type. It can
-    /// be converted to \c int and it has the same operators.
-    class Reference {
-      friend class IterableIntMap;
-    private:
-      Reference(IterableIntMap& map, const Key& key)
-        : _key(key), _map(map) {}
-    public:
-
-      Reference& operator=(const Reference& value) {
-        _map.set(_key, static_cast<const int&>(value));
-         return *this;
-      }
-
-      operator const int&() const {
-        return static_cast<const IterableIntMap&>(_map)[_key];
-      }
-
-      Reference& operator=(int value) {
-        _map.set(_key, value);
-        return *this;
-      }
-      Reference& operator++() {
-        _map.set(_key, _map[_key] + 1);
-        return *this;
-      }
-      int operator++(int) {
-        int value = _map[_key];
-        _map.set(_key, value + 1);
-        return value;
-      }
-      Reference& operator--() {
-        _map.set(_key, _map[_key] - 1);
-        return *this;
-      }
-      int operator--(int) {
-        int value = _map[_key];
-        _map.set(_key, value - 1);
-        return value;
-      }
-      Reference& operator+=(int value) {
-        _map.set(_key, _map[_key] + value);
-        return *this;
-      }
-      Reference& operator-=(int value) {
-        _map.set(_key, _map[_key] - value);
-        return *this;
-      }
-      Reference& operator*=(int value) {
-        _map.set(_key, _map[_key] * value);
-        return *this;
-      }
-      Reference& operator/=(int value) {
-        _map.set(_key, _map[_key] / value);
-        return *this;
-      }
-      Reference& operator%=(int value) {
-        _map.set(_key, _map[_key] % value);
-        return *this;
-      }
-      Reference& operator&=(int value) {
-        _map.set(_key, _map[_key] & value);
-        return *this;
-      }
-      Reference& operator|=(int value) {
-        _map.set(_key, _map[_key] | value);
-        return *this;
-      }
-      Reference& operator^=(int value) {
-        _map.set(_key, _map[_key] ^ value);
-        return *this;
-      }
-      Reference& operator<<=(int value) {
-        _map.set(_key, _map[_key] << value);
-        return *this;
-      }
-      Reference& operator>>=(int value) {
-        _map.set(_key, _map[_key] >> value);
-        return *this;
-      }
-
-    private:
-      Key _key;
-      IterableIntMap& _map;
-    };
-
-    /// The const reference type.
-    typedef const Value& ConstReference;
-
-    /// \brief Gives back the maximal value plus one.
-    ///
-    /// Gives back the maximal value plus one.
-    int size() const {
-      return _first.size();
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, const Value& value) {
-      unlace(key);
-      Parent::operator[](key).value = value;
-      lace(key);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    const Value& operator[](const Key& key) const {
-      return Parent::operator[](key).value;
-    }
-
-    /// \brief Subscript operator of the map.
-    ///
-    /// Subscript operator of the map.
-    Reference operator[](const Key& key) {
-      return Reference(*this, key);
-    }
-
-    /// \brief Iterator for the keys with the same value.
-    ///
-    /// Iterator for the keys with the same value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the item type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid item, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys mapped to the given value.
-      /// \param map The IterableIntMap.
-      /// \param value The value.
-      ItemIt(const IterableIntMap& map, int value) : _map(&map) {
-        if (value < 0 || value >= int(_map->_first.size())) {
-          Parent::operator=(INVALID);
-        } else {
-          Parent::operator=(_map->_first[value]);
-        }
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ItemIt& operator++() {
-        Parent::operator=(_map->IterableIntMap::Parent::
-                          operator[](static_cast<Parent&>(*this)).next);
-        return *this;
-      }
-
-    private:
-      const IterableIntMap* _map;
-    };
-
-  protected:
-
-    virtual void erase(const Key& key) {
-      unlace(key);
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        unlace(keys[i]);
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void clear() {
-      _first.clear();
-      Parent::clear();
-    }
-
-  private:
-    std::vector<Key> _first;
-  };
-
-  namespace _maps_bits {
-    template <typename Item, typename Value>
-    struct IterableValueMapNode {
-      IterableValueMapNode(Value _value = Value()) : value(_value) {}
-      Item prev, next;
-      Value value;
-    };
-  }
-
-  /// \brief Dynamic iterable map for comparable values.
-  ///
-  /// This class provides a special graph map type which can store a
-  /// comparable value for graph items (\c Node, \c Arc or \c Edge).
-  /// For each value it is possible to iterate on the keys mapped to
-  /// the value (\c ItemIt), and the values of the map can be accessed
-  /// with an STL compatible forward iterator (\c ValueIt).
-  /// The map stores a linked list for each value, which contains
-  /// the items mapped to the value, and the used values are stored
-  /// in balanced binary tree (\c std::map).
-  ///
-  /// \ref IterableBoolMap and \ref IterableIntMap are similar classes
-  /// specialized for \c bool and \c int values, respectively.
-  ///
-  /// This type is not reference map, so it cannot be modified with
-  /// the subscript operator.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  /// \tparam V The value type of the map. It can be any comparable
-  /// value type.
-  ///
-  /// \see IterableBoolMap, IterableIntMap
-  /// \see CrossRefMap
-  template <typename GR, typename K, typename V>
-  class IterableValueMap
-    : protected ItemSetTraits<GR, K>::
-        template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {
-  public:
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef V Value;
-    /// The graph type
-    typedef GR Graph;
-
-  public:
-
-    /// \brief Constructor of the map with a given value.
-    ///
-    /// Constructor of the map with a given value.
-    explicit IterableValueMap(const Graph& graph,
-                              const Value& value = Value())
-      : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {
-      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-        lace(it);
-      }
-    }
-
-  protected:
-
-    void unlace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.prev != INVALID) {
-        Parent::operator[](node.prev).next = node.next;
-      } else {
-        if (node.next != INVALID) {
-          _first[node.value] = node.next;
-        } else {
-          _first.erase(node.value);
-        }
-      }
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = node.prev;
-      }
-    }
-
-    void lace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      typename std::map<Value, Key>::iterator it = _first.find(node.value);
-      if (it == _first.end()) {
-        node.prev = node.next = INVALID;
-        _first.insert(std::make_pair(node.value, key));
-      } else {
-        node.prev = INVALID;
-        node.next = it->second;
-        if (node.next != INVALID) {
-          Parent::operator[](node.next).prev = key;
-        }
-        it->second = key;
-      }
-    }
-
-  public:
-
-    /// \brief Forward iterator for values.
-    ///
-    /// This iterator is an STL compatible forward
-    /// iterator on the values of the map. The values can
-    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
-    class ValueIt
-      : public std::iterator<std::forward_iterator_tag, Value> {
-      friend class IterableValueMap;
-    private:
-      ValueIt(typename std::map<Value, Key>::const_iterator _it)
-        : it(_it) {}
-    public:
-
-      /// Constructor
-      ValueIt() {}
-
-      /// \e
-      ValueIt& operator++() { ++it; return *this; }
-      /// \e
-      ValueIt operator++(int) {
-        ValueIt tmp(*this);
-        operator++();
-        return tmp;
-      }
-
-      /// \e
-      const Value& operator*() const { return it->first; }
-      /// \e
-      const Value* operator->() const { return &(it->first); }
-
-      /// \e
-      bool operator==(ValueIt jt) const { return it == jt.it; }
-      /// \e
-      bool operator!=(ValueIt jt) const { return it != jt.it; }
-
-    private:
-      typename std::map<Value, Key>::const_iterator it;
-    };
-
-    /// \brief Returns an iterator to the first value.
-    ///
-    /// Returns an STL compatible iterator to the
-    /// first value of the map. The values of the
-    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
-    /// range.
-    ValueIt beginValue() const {
-      return ValueIt(_first.begin());
-    }
-
-    /// \brief Returns an iterator after the last value.
-    ///
-    /// Returns an STL compatible iterator after the
-    /// last value of the map. The values of the
-    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
-    /// range.
-    ValueIt endValue() const {
-      return ValueIt(_first.end());
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, const Value& value) {
-      unlace(key);
-      Parent::operator[](key).value = value;
-      lace(key);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    const Value& operator[](const Key& key) const {
-      return Parent::operator[](key).value;
-    }
-
-    /// \brief Iterator for the keys with the same value.
-    ///
-    /// Iterator for the keys with the same value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the item type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid item, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys which have the given value.
-      /// \param map The IterableValueMap
-      /// \param value The value
-      ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {
-        typename std::map<Value, Key>::const_iterator it =
-          map._first.find(value);
-        if (it == map._first.end()) {
-          Parent::operator=(INVALID);
-        } else {
-          Parent::operator=(it->second);
-        }
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment Operator.
-      ItemIt& operator++() {
-        Parent::operator=(_map->IterableValueMap::Parent::
-                          operator[](static_cast<Parent&>(*this)).next);
-        return *this;
-      }
-
-
-    private:
-      const IterableValueMap* _map;
-    };
-
-  protected:
-
-    virtual void add(const Key& key) {
-      Parent::add(key);
-      unlace(key);
-    }
-
-    virtual void add(const std::vector<Key>& keys) {
-      Parent::add(keys);
-      for (int i = 0; i < int(keys.size()); ++i) {
-        lace(keys[i]);
-      }
-    }
-
-    virtual void erase(const Key& key) {
-      unlace(key);
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        unlace(keys[i]);
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void build() {
-      Parent::build();
-      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-        lace(it);
-      }
-    }
-
-    virtual void clear() {
-      _first.clear();
-      Parent::clear();
-    }
-
-  private:
-    std::map<Value, Key> _first;
   };
 
@@ -3301 +2341 @@
   public:
 
-    /// The key type (the \c Arc type of the digraph).
+    ///\e
     typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
+    ///\e
     typedef typename GR::Node Value;
 
@@ -3342 +2382 @@
   public:
 
-    /// The key type (the \c Arc type of the digraph).
+    ///\e
     typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
+    ///\e
     typedef typename GR::Node Value;
 
@@ -3384 +2424 @@
   public:
 
-    /// The key type (the \c Edge type of the digraph).
+    typedef typename GR::Arc Value;
     typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
 
     /// \brief Constructor
@@ -3426 +2464 @@
   public:
 
-    /// The key type (the \c Edge type of the digraph).
+    typedef typename GR::Arc Value;
     typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
 
     /// \brief Constructor
@@ -3464 +2500 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of InDegMap is not guarantied if these additional
@@ -3480 +2516 @@
 
   public:
-
+    
     /// The graph type of InDegMap
     typedef GR Graph;
@@ -3594 +2630 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of OutDegMap is not guarantied if these additional

lemon/min_cost_arborescence.h

@@ -489 +489 @@
     /// The simplest way to execute the algorithm is to use
     /// one of the member functions called \c run(...). \n
-    /// If you need better control on the execution,
-    /// you have to call \ref init() first, then you can add several
+    /// If you need more control on the execution,
+    /// first you must call \ref init(), then you can add several
     /// source nodes with \ref addSource().
     /// Finally \ref start() will perform the arborescence

lemon/network_simplex.h

@@ -41 +41 @@
   ///
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
-  /// for finding a \ref min_cost_flow "minimum cost flow"
-  /// \ref amo93networkflows, \ref dantzig63linearprog,
-  /// \ref kellyoneill91netsimplex.
+  /// for finding a \ref min_cost_flow "minimum cost flow".
   /// This algorithm is a specialized version of the linear programming
   /// simplex method directly for the minimum cost flow problem.
@@ -164 +162 @@
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 
+    typedef std::vector<Arc> ArcVector;
+    typedef std::vector<Node> NodeVector;
     typedef std::vector<int> IntVector;
     typedef std::vector<bool> BoolVector;
@@ -365 +365 @@
         Cost c, min = 0;
         int cnt = _block_size;
-        int e;
+        int e, min_arc = _next_arc;
         for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
             min = c;
-            _in_arc = e;
+            min_arc = e;
           }
           if (--cnt == 0) {
-            if (min < 0) goto search_end;
+            if (min < 0) break;
             cnt = _block_size;
           }
         }
-        for (e = 0; e < _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < min) {
-            min = c;
-            _in_arc = e;
-          }
-          if (--cnt == 0) {
-            if (min < 0) goto search_end;
-            cnt = _block_size;
+        if (min == 0 || cnt > 0) {
+          for (e = 0; e < _next_arc; ++e) {
+            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (c < min) {
+              min = c;
+              min_arc = e;
+            }
+            if (--cnt == 0) {
+              if (min < 0) break;
+              cnt = _block_size;
+            }
           }
         }
         if (min >= 0) return false;
-
-      search_end:
+        _in_arc = min_arc;
         _next_arc = e;
         return true;
@@ -428 +429 @@
       {
         // The main parameters of the pivot rule
-        const double LIST_LENGTH_FACTOR = 0.25;
+        const double LIST_LENGTH_FACTOR = 1.0;
         const int MIN_LIST_LENGTH = 10;
         const double MINOR_LIMIT_FACTOR = 0.1;
@@ -445 +446 @@
       bool findEnteringArc() {
         Cost min, c;
-        int e;
+        int e, min_arc = _next_arc;
         if (_curr_length > 0 && _minor_count < _minor_limit) {
           // Minor iteration: select the best eligible arc from the
@@ -456 +457 @@
             if (c < min) {
               min = c;
-              _in_arc = e;
+              min_arc = e;
             }
-            else if (c >= 0) {
+            if (c >= 0) {
               _candidates[i--] = _candidates[--_curr_length];
             }
           }
-          if (min < 0) return true;
+          if (min < 0) {
+            _in_arc = min_arc;
+            return true;
+          }
         }
 
@@ -474 +478 @@
             if (c < min) {
               min = c;
-              _in_arc = e;
+              min_arc = e;
             }
-            if (_curr_length == _list_length) goto search_end;
-          }
-        }
-        for (e = 0; e < _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _candidates[_curr_length++] = e;
-            if (c < min) {
-              min = c;
-              _in_arc = e;
+            if (_curr_length == _list_length) break;
+          }
+        }
+        if (_curr_length < _list_length) {
+          for (e = 0; e < _next_arc; ++e) {
+            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (c < 0) {
+              _candidates[_curr_length++] = e;
+              if (c < min) {
+                min = c;
+                min_arc = e;
+              }
+              if (_curr_length == _list_length) break;
             }
-            if (_curr_length == _list_length) goto search_end;
           }
         }
         if (_curr_length == 0) return false;
-      
-      search_end:        
         _minor_count = 1;
+        _in_arc = min_arc;
         _next_arc = e;
         return true;
@@ -545 +550 @@
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
+        const double BLOCK_SIZE_FACTOR = 1.5;
         const int MIN_BLOCK_SIZE = 10;
         const double HEAD_LENGTH_FACTOR = 0.1;
@@ -574 +579 @@
         // Extend the list
         int cnt = _block_size;
+        int last_arc = 0;
         int limit = _head_length;
 
-        for (e = _next_arc; e < _search_arc_num; ++e) {
+        for (int e = _next_arc; e < _search_arc_num; ++e) {
           _cand_cost[e] = _state[e] *
             (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (_cand_cost[e] < 0) {
             _candidates[_curr_length++] = e;
+            last_arc = e;
           }
           if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
+            if (_curr_length > limit) break;
             limit = 0;
             cnt = _block_size;
           }
         }
-        for (e = 0; e < _next_arc; ++e) {
-          _cand_cost[e] = _state[e] *
-            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (_cand_cost[e] < 0) {
-            _candidates[_curr_length++] = e;
-          }
-          if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
-            limit = 0;
-            cnt = _block_size;
+        if (_curr_length <= limit) {
+          for (int e = 0; e < _next_arc; ++e) {
+            _cand_cost[e] = _state[e] *
+              (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (_cand_cost[e] < 0) {
+              _candidates[_curr_length++] = e;
+              last_arc = e;
+            }
+            if (--cnt == 0) {
+              if (_curr_length > limit) break;
+              limit = 0;
+              cnt = _block_size;
+            }
           }
         }
         if (_curr_length == 0) return false;
-        
-      search_end:
+        _next_arc = last_arc + 1;
 
         // Make heap of the candidate list (approximating a partial sort)
@@ -610 +619 @@
         // Pop the first element of the heap
         _in_arc = _candidates[0];
-        _next_arc = e;
         pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
                   _sort_func );
@@ -626 +634 @@
     ///
     /// \param graph The digraph the algorithm runs on.
-    /// \param arc_mixing Indicate if the arcs have to be stored in a
-    /// mixed order in the internal data structure. 
-    /// In special cases, it could lead to better overall performance,
-    /// but it is usually slower. Therefore it is disabled by default.
-    NetworkSimplex(const GR& graph, bool arc_mixing = false) :
+    NetworkSimplex(const GR& graph) :
       _graph(graph), _node_id(graph), _arc_id(graph),
       INF(std::numeric_limits<Value>::has_infinity ?
@@ -668 +672 @@
       _state.resize(max_arc_num);
 
-      // Copy the graph
+      // Copy the graph (store the arcs in a mixed order)
       int i = 0;
       for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
         _node_id[n] = i;
       }
-      if (arc_mixing) {
-        // Store the arcs in a mixed order
-        int k = std::max(int(std::sqrt(double(_arc_num))), 10);
-        int i = 0, j = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-          if ((i += k) >= _arc_num) i = ++j;
-        }
-      } else {
-        // Store the arcs in the original order
-        int i = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-        }
+      int k = std::max(int(std::sqrt(double(_arc_num))), 10);
+      i = 0;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _arc_id[a] = i;
+        _source[i] = _node_id[_graph.source(a)];
+        _target[i] = _node_id[_graph.target(a)];
+        if ((i += k) >= _arc_num) i = (i % k) + 1;
       }
       
-      // Reset parameters
-      reset();
+      // Initialize maps
+      for (int i = 0; i != _node_num; ++i) {
+        _supply[i] = 0;
+      }
+      for (int i = 0; i != _arc_num; ++i) {
+        _lower[i] = 0;
+        _upper[i] = INF;
+        _cost[i] = 1;
+      }
+      _have_lower = false;
+      _stype = GEQ;
     }
 
@@ -767 +769 @@
     /// If neither this function nor \ref stSupply() is used before
     /// calling \ref run(), the supply of each node will be set to zero.
+    /// (It makes sense only if non-zero lower bounds are given.)
     ///
     /// \param map A node map storing the supply values.
@@ -787 +790 @@
     /// If neither this function nor \ref supplyMap() is used before
     /// calling \ref run(), the supply of each node will be set to zero.
+    /// (It makes sense only if non-zero lower bounds are given.)
     ///
     /// Using this function has the same effect as using \ref supplyMap()

lemon/path.h

@@ -1016 +1016 @@
   /// \brief The source of a path
   ///
-  /// This function returns the source node of the given path.
-  /// If the path is empty, then it returns \c INVALID.
+  /// This function returns the source of the given path.
   template <typename Digraph, typename Path>
   typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) {
-    return path.empty() ? INVALID : digraph.source(path.front());
+    return digraph.source(path.front());
   }
 
   /// \brief The target of a path
   ///
-  /// This function returns the target node of the given path.
-  /// If the path is empty, then it returns \c INVALID.
+  /// This function returns the target of the given path.
   template <typename Digraph, typename Path>
   typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {
-    return path.empty() ? INVALID : digraph.target(path.back());
+    return digraph.target(path.back());
   }
 

lemon/preflow.h

@@ -53 +53 @@
     /// The type of the map that stores the flow values.
     /// It must meet 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.
@@ -72 +68 @@
     /// The elevator type used by Preflow algorithm.
     ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
-    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
+    /// \sa Elevator
+    /// \sa LinkedElevator
+    typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
 
     /// \brief Instantiates an Elevator.
@@ -103 +96 @@
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
   /// \e push-relabel algorithm producing a \ref max_flow
-  /// "flow of maximum value" in a digraph \ref clrs01algorithms,
-  /// \ref amo93networkflows, \ref goldberg88newapproach.
+  /// "flow of maximum value" in a digraph.
   /// The preflow algorithms are the fastest known maximum
-  /// flow algorithms. The current implementation uses a mixture of the
+  /// flow algorithms. The current implementation use a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
   /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
@@ -380 +372 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    Preflow& tolerance(const Tolerance& tolerance) {
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
+    Preflow& tolerance(const Tolerance& tolerance) const {
       _tolerance = tolerance;
       return *this;
@@ -391 +382 @@
     /// \brief Returns a const reference to the tolerance.
     ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
+    /// Returns a const reference to the tolerance.
     const Tolerance& tolerance() const {
-      return _tolerance;
+      return tolerance;
     }
 
@@ -400 +390 @@
     /// The simplest way to execute the preflow algorithm is to use
     /// \ref run() or \ref runMinCut().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
+    /// If you need more control on the initial solution or the execution,
+    /// first you have to call one of the \ref init() functions, then
     /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
 

lemon/radix_heap.h

@@ -20 +20 @@
 #define LEMON_RADIX_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Radix heap implementation.
+///\brief Radix Heap implementation.
 
 #include <vector>
@@ -30 +30 @@
 
 
-  /// \ingroup heaps
+  /// \ingroup auxdata
   ///
-  /// \brief Radix heap data structure.
+  /// \brief A Radix Heap implementation.
   ///
-  /// This class implements the \e radix \e heap data structure.
-  /// It practically conforms to the \ref concepts::Heap "heap concept",
-  /// but it has some limitations due its special implementation.
-  /// The type of the priorities must be \c int and the priority of an
-  /// item cannot be decreased under the priority of the last removed item.
+  /// This class implements the \e radix \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. This heap type can store only items with \e int priority.
+  /// In a heap one can change the priority of an item, add or erase an
+  /// item, but the priority cannot be decreased under the last removed
+  /// item's priority.
   ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
+  /// \param IM A read and writable Item int map, used internally
+  /// to handle the cross references.
+  ///
+  /// \see BinHeap
+  /// \see Dijkstra
   template <typename IM>
   class RadixHeap {
 
   public:
-
-    /// Type of the item-int map.
+    typedef typename IM::Key Item;
+    typedef int Prio;
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
 
     /// \brief Exception thrown by RadixHeap.
     ///
-    /// This exception is thrown when an item is inserted into a
-    /// RadixHeap with a priority smaller than the last erased one.
+    /// This Exception is thrown when a smaller priority
+    /// is inserted into the \e RadixHeap then the last time erased.
     /// \see RadixHeap
-    class PriorityUnderflowError : public Exception {
+
+    class UnderFlowPriorityError : public Exception {
     public:
       virtual const char* what() const throw() {
-        return "lemon::RadixHeap::PriorityUnderflowError";
+        return "lemon::RadixHeap::UnderFlowPriorityError";
       }
     };
 
-    /// \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
+    /// \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
     /// 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
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    /// The ItemIntMap \e should be initialized in such way that it maps
+    /// PRE_HEAP (-1) to any element to be put in the heap...
     enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
+      IN_HEAP = 0,
+      PRE_HEAP = -1,
+      POST_HEAP = -2
     };
 
@@ -95 +97 @@
     };
 
-    std::vector<RadixItem> _data;
-    std::vector<RadixBox> _boxes;
+    std::vector<RadixItem> data;
+    std::vector<RadixBox> boxes;
 
     ItemIntMap &_iim;
 
+
   public:
-
-    /// \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 minimum The initial minimum value of the heap.
-    /// \param capacity The initial capacity of the heap.
-    RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)
-      : _iim(map)
-    {
-      _boxes.push_back(RadixBox(minimum, 1));
-      _boxes.push_back(RadixBox(minimum + 1, 1));
-      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    ///
+    /// \param map It 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 minimal The initial minimal value of the heap.
+    /// \param capacity It determines the initial capacity of the heap.
+    RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0)
+      : _iim(map) {
+      boxes.push_back(RadixBox(minimal, 1));
+      boxes.push_back(RadixBox(minimal + 1, 1));
+      while (lower(boxes.size() - 1, capacity + minimal - 1)) {
         extend();
       }
     }
 
-    /// \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 Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \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.
-    /// \param minimum The minimum value of the heap.
-    /// \param capacity The capacity of the heap.
-    void clear(int minimum = 0, int capacity = 0) {
-      _data.clear(); _boxes.clear();
-      _boxes.push_back(RadixBox(minimum, 1));
-      _boxes.push_back(RadixBox(minimum + 1, 1));
-      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
+    /// The number of items stored in the heap.
+    ///
+    /// \brief 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.
+    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.
+    void clear(int minimal = 0, int capacity = 0) {
+      data.clear(); boxes.clear();
+      boxes.push_back(RadixBox(minimal, 1));
+      boxes.push_back(RadixBox(minimal + 1, 1));
+      while (lower(boxes.size() - 1, capacity + minimal - 1)) {
         extend();
       }
@@ -151 +150 @@
 
     bool upper(int box, Prio pr) {
-      return pr < _boxes[box].min;
+      return pr < boxes[box].min;
     }
 
     bool lower(int box, Prio pr) {
-      return pr >= _boxes[box].min + _boxes[box].size;
-    }
-
-    // Remove item from the box list
+      return pr >= boxes[box].min + boxes[box].size;
+    }
+
+    /// \brief Remove item from the box list.
     void remove(int index) {
-      if (_data[index].prev >= 0) {
-        _data[_data[index].prev].next = _data[index].next;
+      if (data[index].prev >= 0) {
+        data[data[index].prev].next = data[index].next;
       } else {
-        _boxes[_data[index].box].first = _data[index].next;
-      }
-      if (_data[index].next >= 0) {
-        _data[_data[index].next].prev = _data[index].prev;
-      }
-    }
-
-    // Insert item into the box list
+        boxes[data[index].box].first = data[index].next;
+      }
+      if (data[index].next >= 0) {
+        data[data[index].next].prev = data[index].prev;
+      }
+    }
+
+    /// \brief Insert item into the box list.
     void insert(int box, int index) {
-      if (_boxes[box].first == -1) {
-        _boxes[box].first = index;
-        _data[index].next = _data[index].prev = -1;
+      if (boxes[box].first == -1) {
+        boxes[box].first = index;
+        data[index].next = data[index].prev = -1;
       } else {
-        _data[index].next = _boxes[box].first;
-        _data[_boxes[box].first].prev = index;
-        _data[index].prev = -1;
-        _boxes[box].first = index;
-      }
-      _data[index].box = box;
-    }
-
-    // Add a new box to the box list
+        data[index].next = boxes[box].first;
+        data[boxes[box].first].prev = index;
+        data[index].prev = -1;
+        boxes[box].first = index;
+      }
+      data[index].box = box;
+    }
+
+    /// \brief Add a new box to the box list.
     void extend() {
-      int min = _boxes.back().min + _boxes.back().size;
-      int bs = 2 * _boxes.back().size;
-      _boxes.push_back(RadixBox(min, bs));
-    }
-
-    // Move an item up into the proper box.
-    void bubbleUp(int index) {
-      if (!lower(_data[index].box, _data[index].prio)) return;
+      int min = boxes.back().min + boxes.back().size;
+      int bs = 2 * boxes.back().size;
+      boxes.push_back(RadixBox(min, bs));
+    }
+
+    /// \brief Move an item up into the proper box.
+    void bubble_up(int index) {
+      if (!lower(data[index].box, data[index].prio)) return;
       remove(index);
-      int box = findUp(_data[index].box, _data[index].prio);
+      int box = findUp(data[index].box, data[index].prio);
       insert(box, index);
     }
 
-    // Find up the proper box for the item with the given priority
+    /// \brief Find up the proper box for the item with the given prio.
     int findUp(int start, int pr) {
       while (lower(start, pr)) {
-        if (++start == int(_boxes.size())) {
+        if (++start == int(boxes.size())) {
           extend();
         }
@@ -209 +208 @@
     }
 
-    // Move an item down into the proper box
-    void bubbleDown(int index) {
-      if (!upper(_data[index].box, _data[index].prio)) return;
+    /// \brief Move an item down into the proper box.
+    void bubble_down(int index) {
+      if (!upper(data[index].box, data[index].prio)) return;
       remove(index);
-      int box = findDown(_data[index].box, _data[index].prio);
+      int box = findDown(data[index].box, data[index].prio);
       insert(box, index);
     }
 
-    // Find down the proper box for the item with the given priority
+    /// \brief Find up the proper box for the item with the given prio.
     int findDown(int start, int pr) {
       while (upper(start, pr)) {
-        if (--start < 0) throw PriorityUnderflowError();
+        if (--start < 0) throw UnderFlowPriorityError();
       }
       return start;
     }
 
-    // Find the first non-empty box
+    /// \brief Find the first not empty box.
     int findFirst() {
       int first = 0;
-      while (_boxes[first].first == -1) ++first;
+      while (boxes[first].first == -1) ++first;
       return first;
     }
 
-    // Gives back the minimum priority of the given box
+    /// \brief Gives back the minimal prio of the box.
     int minValue(int box) {
-      int min = _data[_boxes[box].first].prio;
-      for (int k = _boxes[box].first; k != -1; k = _data[k].next) {
-        if (_data[k].prio < min) min = _data[k].prio;
+      int min = data[boxes[box].first].prio;
+      for (int k = boxes[box].first; k != -1; k = data[k].next) {
+        if (data[k].prio < min) min = data[k].prio;
       }
       return min;
     }
 
-    // Rearrange the items of the heap and make the first box non-empty
+    /// \brief Rearrange the items of the heap and makes the
+    /// first box not empty.
     void moveDown() {
       int box = findFirst();
@@ -247 +247 @@
       int min = minValue(box);
       for (int i = 0; i <= box; ++i) {
-        _boxes[i].min = min;
-        min += _boxes[i].size;
-      }
-      int curr = _boxes[box].first, next;
+        boxes[i].min = min;
+        min += boxes[i].size;
+      }
+      int curr = boxes[box].first, next;
       while (curr != -1) {
-        next = _data[curr].next;
-        bubbleDown(curr);
+        next = data[curr].next;
+        bubble_down(curr);
         curr = next;
       }
     }
 
-    void relocateLast(int index) {
-      if (index != int(_data.size()) - 1) {
-        _data[index] = _data.back();
-        if (_data[index].prev != -1) {
-          _data[_data[index].prev].next = index;
+    void relocate_last(int index) {
+      if (index != int(data.size()) - 1) {
+        data[index] = data.back();
+        if (data[index].prev != -1) {
+          data[data[index].prev].next = index;
         } else {
-          _boxes[_data[index].box].first = index;
+          boxes[data[index].box].first = index;
         }
-        if (_data[index].next != -1) {
-          _data[_data[index].next].prev = index;
+        if (data[index].next != -1) {
+          data[data[index].next].prev = index;
         }
-        _iim[_data[index].item] = index;
-      }
-      _data.pop_back();
+        _iim[data[index].item] = index;
+      }
+      data.pop_back();
     }
 
@@ -278 +278 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void push(const Item &i, const Prio &p) {
-      int n = _data.size();
+      int n = data.size();
       _iim.set(i, n);
-      _data.push_back(RadixItem(i, p));
-      while (lower(_boxes.size() - 1, p)) {
+      data.push_back(RadixItem(i, p));
+      while (lower(boxes.size() - 1, p)) {
         extend();
       }
-      int box = findDown(_boxes.size() - 1, p);
+      int box = findDown(boxes.size() - 1, p);
       insert(box, n);
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+      return data[boxes[0].first].item;
+    }
+
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].prio;
+      return data[boxes[0].first].prio;
      }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
       moveDown();
-      int index = _boxes[0].first;
-      _iim[_data[index].item] = POST_HEAP;
+      int index = boxes[0].first;
+      _iim[data[index].item] = POST_HEAP;
       remove(index);
-      relocateLast(index);
-    }
-
-    /// \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.
+      relocate_last(index);
+    }
+
+    /// \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.
     void erase(const Item &i) {
       int index = _iim[i];
       _iim[i] = POST_HEAP;
       remove(index);
-      relocateLast(index);
+      relocate_last(index);
    }
 
-    /// \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.
+    /// \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.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
-      return _data[idx].prio;
-    }
-
-    /// \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.
+      return data[idx].prio;
+    }
+
+    /// \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.
+    /// It may throw an \e UnderFlowPriorityException.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be in the heap.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void set(const Item &i, const Prio &p) {
       int idx = _iim[i];
@@ -363 +357 @@
         push(i, p);
       }
-      else if( p >= _data[idx].prio ) {
-        _data[idx].prio = p;
-        bubbleUp(idx);
+      else if( p >= data[idx].prio ) {
+        data[idx].prio = p;
+        bubble_up(idx);
       } else {
-        _data[idx].prio = p;
-        bubbleDown(idx);
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+        data[idx].prio = p;
+        bubble_down(idx);
+      }
+    }
+
+
+    /// \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, and
+    /// \c should be greater or equal to the last removed item's priority.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      _data[idx].prio = p;
-      bubbleDown(idx);
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+      data[idx].prio = p;
+      bubble_down(idx);
+    }
+
+    /// \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
     /// \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];
-      _data[idx].prio = p;
-      bubbleUp(idx);
-    }
-
-    /// \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.
+      data[idx].prio = p;
+      bubble_up(idx);
+    }
+
+    /// \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.
     /// \param i The item.
     State state(const Item &i) const {
@@ -411 +406 @@
     }
 
-    /// \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.
+    /// \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.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.

lemon/smart_graph.h

@@ -33 +33 @@
 
   class SmartDigraph;
-
+  ///Base of SmartDigraph
+
+  ///Base of SmartDigraph
+  ///
   class SmartDigraphBase {
   protected:
@@ -185 +188 @@
   ///\brief A smart directed graph class.
   ///
-  ///\ref SmartDigraph is a simple and fast digraph implementation.
-  ///It is also quite memory efficient but at the price
-  ///that it does not support node and arc deletion 
-  ///(except for the Snapshot feature).
+  ///This is a simple and fast digraph implementation.
+  ///It is also quite memory efficient, but at the price
+  ///that <b> it does support only limited (only stack-like)
+  ///node and arc deletions</b>.
+  ///It fully conforms to the \ref concepts::Digraph "Digraph concept".
   ///
-  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
-  ///and it also provides some additional functionalities.
-  ///Most of its member functions and nested classes are documented
-  ///only in the concept class.
-  ///
-  ///\sa concepts::Digraph
-  ///\sa SmartGraph
+  ///\sa concepts::Digraph.
   class SmartDigraph : public ExtendedSmartDigraphBase {
     typedef ExtendedSmartDigraphBase Parent;
 
   private:
-    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
+
+    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+
+    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+    ///
     SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {};
-    /// \brief Assignment of a digraph to another one is \e not allowed.
-    /// Use DigraphCopy instead.
+    ///\brief Assignment of SmartDigraph to another one is \e not allowed.
+    ///Use DigraphCopy() instead.
+
+    ///Assignment of SmartDigraph to another one is \e not allowed.
+    ///Use DigraphCopy() instead.
     void operator=(const SmartDigraph &) {}
 
@@ -217 +222 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
-    ///\return The new node.
+    /// Add a new node to the digraph.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
     ///Add a new arc to the digraph.
 
-    ///This function adds a new arc to the digraph with source node \c s
+    ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return The new arc.
-    Arc addArc(Node s, Node t) {
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
 
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
+
+    /// Using this it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveArc
+    void reserveNode(int n) { nodes.reserve(n); };
+
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
+
+    /// Using this it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveNode
+    void reserveArc(int m) { arcs.reserve(m); };
+
     /// \brief Node validity check
     ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the digraph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
     ///
     /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the digraph.
+    /// when new nodes are added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
     /// \brief Arc validity check
     ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the digraph.
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
     ///
     /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new arcs are added to the graph.
+    /// when new arcs are added to the graph.
     bool valid(Arc a) const { return Parent::valid(a); }
 
+    ///Clear the digraph.
+
+    ///Erase all the nodes and arcs from the digraph.
+    ///
+    void clear() {
+      Parent::clear();
+    }
+
     ///Split a node.
 
-    ///This function splits the given node. First, a new node is added
-    ///to the digraph, then the source of each outgoing arc of node \c n
-    ///is moved to this new node.
-    ///If the second parameter \c connect is \c true (this is the default
-    ///value), then a new arc from node \c n to the newly created node
-    ///is also added.
+    ///This function splits a node. First a new node is added to the digraph,
+    ///then the source of each outgoing arc of \c n is moved to this new node.
+    ///If \c connect is \c true (this is the default value), then a new arc
+    ///from \c n to the newly created node is also added.
     ///\return The newly created node.
     ///
-    ///\note All iterators remain valid.
-    ///
+    ///\note The <tt>Arc</tt>s
+    ///referencing a moved arc remain
+    ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
+    ///may be invalidated.
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
@@ -274 +309 @@
     }
 
-    ///Clear the digraph.
-
-    ///This function erases all nodes and arcs from the digraph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for arcs.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
-
   public:
 
@@ -326 +333 @@
   public:
 
-    ///Class to make a snapshot of the digraph and to restore it later.
-
-    ///Class to make a snapshot of the digraph and to restore it later.
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+
+    ///Class to make a snapshot of the digraph and to restrore to it later.
     ///
     ///The newly added nodes and arcs can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///arcs from a SmartDigraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state, 
-    ///i.e. you cannot add the removed nodes and arcs again using
-    ///another Snapshot instance.
-    ///
-    ///\warning Node splitting cannot be restored.
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the digraph or no change.
+    ///restore() function.
+    ///\note After you restore a state, you cannot restore
+    ///a later state, in other word you cannot add again the arcs deleted
+    ///by restore() using another one Snapshot instance.
+    ///
+    ///\warning If you do not use correctly the snapshot that can cause
+    ///either broken program, invalid state of the digraph, valid but
+    ///not the restored digraph or no change. Because the runtime performance
+    ///the validity of the snapshot is not stored.
     class Snapshot
     {
@@ -354 +358 @@
 
       ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
+      ///To actually make a snapshot you must call save().
+      ///
       Snapshot() : _graph(0) {}
       ///Constructor that immediately makes a snapshot
 
-      ///This constructor immediately makes a snapshot of the given digraph.
-      ///
-      Snapshot(SmartDigraph &gr) : _graph(&gr) {
+      ///This constructor immediately makes a snapshot of the digraph.
+      ///\param graph The digraph we make a snapshot of.
+      Snapshot(SmartDigraph &graph) : _graph(&graph) {
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
@@ -367 +372 @@
       ///Make a snapshot.
 
-      ///This function makes a snapshot of the given digraph.
-      ///It can be called more than once. In case of a repeated
+      ///Make a snapshot of the digraph.
+      ///
+      ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
-      void save(SmartDigraph &gr) {
-        _graph=&gr;
+      ///\param graph The digraph we make the snapshot of.
+      void save(SmartDigraph &graph)
+      {
+        _graph=&graph;
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
@@ -378 +386 @@
       ///Undo the changes until a snapshot.
 
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartDigraph&).
+      ///Undo the changes until a snapshot created by save().
+      ///
+      ///\note After you restored a state, you cannot restore
+      ///a later state, in other word you cannot add again the arcs deleted
+      ///by restore().
       void restore()
       {
@@ -611 +622 @@
   /// \brief A smart undirected graph class.
   ///
-  /// \ref SmartGraph is a simple and fast graph implementation.
-  /// It is also quite memory efficient but at the price
-  /// that it does not support node and edge deletion 
-  /// (except for the Snapshot feature).
+  /// This is a simple and fast graph implementation.
+  /// It is also quite memory efficient, but at the price
+  /// that <b> it does support only limited (only stack-like)
+  /// node and arc deletions</b>.
+  /// It fully conforms to the \ref concepts::Graph "Graph concept".
   ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept"
-  /// and it also provides some additional functionalities.
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// \sa concepts::Graph
-  /// \sa SmartDigraph
+  /// \sa concepts::Graph.
   class SmartGraph : public ExtendedSmartGraphBase {
     typedef ExtendedSmartGraphBase Parent;
 
   private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+
+    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
+
+    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
+    ///
     SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
+
+    ///\brief Assignment of SmartGraph to another one is \e not allowed.
+    ///Use GraphCopy() instead.
+
+    ///Assignment of SmartGraph to another one is \e not allowed.
+    ///Use GraphCopy() instead.
     void operator=(const SmartGraph &) {}
 
@@ -641 +655 @@
     SmartGraph() {}
 
-    /// \brief Add a new node to the graph.
-    ///
-    /// This function adds a new node to the graph.
+    ///Add a new node to the graph.
+
+    /// Add a new node to the graph.
     /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(Node u, Node v) {
-      return Parent::addEdge(u, v);
+    ///Add a new edge to the graph.
+
+    ///Add a new edge to the graph with node \c s
+    ///and \c t.
+    ///\return The new edge.
+    Edge addEdge(const Node& s, const Node& t) {
+      return Parent::addEdge(s, t);
     }
 
     /// \brief Node validity check
     ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
     ///
     /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the graph.
+    /// when new nodes are added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
+    /// \brief Arc validity check
+    ///
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning A removed arc (using Snapshot) could become valid again
+    /// when new edges are added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
+
     /// \brief Edge validity check
     ///
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
+    /// This function gives back true if the given edge is valid,
+    /// ie. it is a real edge of the graph.
     ///
     /// \warning A removed edge (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
+    /// when new edges are added to the graph.
     bool valid(Edge e) const { return Parent::valid(e); }
 
-    /// \brief Arc validity check
-    ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
     ///Clear the graph.
 
-    ///This function erases all nodes and arcs from the graph.
+    ///Erase all the nodes and edges from the graph.
     ///
     void clear() {
       Parent::clear();
     }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -750 +743 @@
   public:
 
-    ///Class to make a snapshot of the graph and to restore it later.
-
-    ///Class to make a snapshot of the graph and to restore it later.
-    ///
-    ///The newly added nodes and edges can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///edges from a SmartGraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state, 
-    ///i.e. you cannot add the removed nodes and edges again using
-    ///another Snapshot instance.
-    ///
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the graph or no change.
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+    ///
+    ///The newly added nodes and arcs can be removed using the
+    ///restore() function.
+    ///
+    ///\note After you restore a state, you cannot restore
+    ///a later state, in other word you cannot add again the arcs deleted
+    ///by restore() using another one Snapshot instance.
+    ///
+    ///\warning If you do not use correctly the snapshot that can cause
+    ///either broken program, invalid state of the digraph, valid but
+    ///not the restored digraph or no change. Because the runtime performance
+    ///the validity of the snapshot is not stored.
     class Snapshot
     {
@@ -777 +769 @@
 
       ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
+      ///To actually make a snapshot you must call save().
+      ///
       Snapshot() : _graph(0) {}
       ///Constructor that immediately makes a snapshot
 
-      /// This constructor immediately makes a snapshot of the given graph.
+      ///This constructor immediately makes a snapshot of the digraph.
+      ///\param graph The digraph we make a snapshot of.
+      Snapshot(SmartGraph &graph) {
+        graph.saveSnapshot(*this);
+      }
+
+      ///Make a snapshot.
+
+      ///Make a snapshot of the graph.
       ///
-      Snapshot(SmartGraph &gr) {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Make a snapshot.
-
-      ///This function makes a snapshot of the given graph.
-      ///It can be called more than once. In case of a repeated
+      ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
-      void save(SmartGraph &gr)
+      ///\param graph The digraph we make the snapshot of.
+      void save(SmartGraph &graph)
       {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Undo the changes until the last snapshot.
-
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartGraph&).
+        graph.saveSnapshot(*this);
+      }
+
+      ///Undo the changes until a snapshot.
+
+      ///Undo the changes until a snapshot created by save().
+      ///
+      ///\note After you restored a state, you cannot restore
+      ///a later state, in other word you cannot add again the arcs deleted
+      ///by restore().
       void restore()
       {

lemon/soplex.cc

@@ -92 +92 @@
   }
 
-  int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    soplex::DSVector v;
-    for (ExprIterator it = b; it != e; ++it) {
-      v.add(it->first, it->second);
-    }
-    soplex::LPRow r(l, v, u);
-    soplex->addRow(r);
-
-    _row_names.push_back(std::string());
-
-    return soplex->nRows() - 1;
-  }
-
 
   void SoplexLp::_eraseCol(int i) {

lemon/soplex.h

@@ -85 +85 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);

m4/lx_check_coin.m4

@@ -89 +89 @@
         CBC_LDFLAGS="-L$with_coin/lib"
       fi
-      CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
+      CBC_LIBS="-lOsi -lCbc -lOsiCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
 
       lx_save_cxxflags="$CXXFLAGS"

scripts/chg-len.py

@@ -1 +1 @@
 #! /usr/bin/env python
-#
-# This file is a part of LEMON, a generic C++ optimization library.
-#
-# Copyright (C) 2003-2009
-# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-# (Egervary Research Group on Combinatorial Optimization, EGRES).
-#
-# Permission to use, modify and distribute this software is granted
-# provided that this copyright notice appears in all copies. For
-# precise terms see the accompanying LICENSE file.
-#
-# This software is provided "AS IS" with no warranty of any kind,
-# express or implied, and with no claim as to its suitability for any
-# purpose.
 
 import sys

scripts/mk-release.sh

@@ -1 +1 @@
 #!/bin/bash
-#
-# This file is a part of LEMON, a generic C++ optimization library.
-#
-# Copyright (C) 2003-2009
-# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-# (Egervary Research Group on Combinatorial Optimization, EGRES).
-#
-# Permission to use, modify and distribute this software is granted
-# provided that this copyright notice appears in all copies. For
-# precise terms see the accompanying LICENSE file.
-#
-# This software is provided "AS IS" with no warranty of any kind,
-# express or implied, and with no claim as to its suitability for any
-# purpose.
 
 set -e

scripts/unify-sources.sh

@@ -1 +1 @@
 #!/bin/bash
-#
-# This file is a part of LEMON, a generic C++ optimization library.
-#
-# Copyright (C) 2003-2009
-# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-# (Egervary Research Group on Combinatorial Optimization, EGRES).
-#
-# Permission to use, modify and distribute this software is granted
-# provided that this copyright notice appears in all copies. For
-# precise terms see the accompanying LICENSE file.
-#
-# This software is provided "AS IS" with no warranty of any kind,
-# express or implied, and with no claim as to its suitability for any
-# purpose.
 
 YEAR=`date +%Y`

test/CMakeLists.txt

@@ -10 +10 @@
 SET(TESTS
   adaptors_test
-  bellman_ford_test
   bfs_test
   circulation_test
@@ -33 +32 @@
   min_cost_arborescence_test
   min_cost_flow_test
-  min_mean_cycle_test
   path_test
   preflow_test

test/Makefile.am

@@ -8 +8 @@
 check_PROGRAMS += \
         test/adaptors_test \
-        test/bellman_ford_test \
         test/bfs_test \
         test/circulation_test \
@@ -31 +30 @@
         test/min_cost_arborescence_test \
         test/min_cost_flow_test \
-        test/min_mean_cycle_test \
         test/path_test \
         test/preflow_test \
@@ -55 +53 @@
 
 test_adaptors_test_SOURCES = test/adaptors_test.cc
-test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc
 test_bfs_test_SOURCES = test/bfs_test.cc
 test_circulation_test_SOURCES = test/circulation_test.cc
@@ -80 +77 @@
 test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
 test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc
-test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc
 test_path_test_SOURCES = test/path_test.cc
 test_preflow_test_SOURCES = test/preflow_test.cc

test/circulation_test.cc

@@ -88 +88 @@
     .supplyMap(supply)
     .flowMap(flow);
-  
-  const CirculationType::Elevator& elev = const_circ_test.elevator();
-  circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
-  CirculationType::Tolerance tol = const_circ_test.tolerance();
-  circ_test.tolerance(tol);
 
   circ_test.init();

test/digraph_test.cc

@@ -37 +37 @@
   checkGraphArcList(G, 0);
 
-  G.reserveNode(3);
-  G.reserveArc(4);
-
   Node
     n1 = G.addNode(),
@@ -284 +281 @@
   G.addNode();
   snapshot.save(G);
-
-  G.addArc(G.addNode(), G.addNode());
-
-  snapshot.restore();
-  snapshot.save(G);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 4);
 
   G.addArc(G.addNode(), G.addNode());
@@ -499 +488 @@
   typedef FullDigraph Digraph;
   DIGRAPH_TYPEDEFS(Digraph);
-
   Digraph G(num);
-  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
-
-  G.resize(num);
-  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
 
   checkGraphNodeList(G, num);

test/graph_test.cc

@@ -39 +39 @@
   checkGraphArcList(G, 0);
 
-  G.reserveNode(3);
-  G.reserveEdge(3);
-
   Node
     n1 = G.addNode(),
@@ -260 +257 @@
 
   snapshot.restore();
-  snapshot.save(G);
 
   checkGraphNodeList(G, 4);
   checkGraphEdgeList(G, 3);
   checkGraphArcList(G, 6);
-  
-  G.addEdge(G.addNode(), G.addNode());
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
 }
 
@@ -280 +268 @@
 
   Graph G(num);
-  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
-        "Wrong size");
-
-  G.resize(num);
-  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
-        "Wrong size");
-
   checkGraphNodeList(G, num);
   checkGraphEdgeList(G, num * (num - 1) / 2);
@@ -431 +412 @@
   check(G.height() == height, "Wrong row number");
 
-  G.resize(width, height);
-  check(G.width() == width, "Wrong column number");
-  check(G.height() == height, "Wrong row number");
-
   for (int i = 0; i < width; ++i) {
     for (int j = 0; j < height; ++j) {
@@ -510 +487 @@
 
   HypercubeGraph G(dim);
-  check(G.dimension() == dim, "Wrong dimension");
-
-  G.resize(dim);
-  check(G.dimension() == dim, "Wrong dimension");
-  
   checkGraphNodeList(G, 1 << dim);
   checkGraphEdgeList(G, dim * (1 << (dim-1)));

test/heap_test.cc

@@ -26 +26 @@
 
 #include <lemon/smart_graph.h>
+
 #include <lemon/lgf_reader.h>
 #include <lemon/dijkstra.h>
@@ -31 +32 @@
 
 #include <lemon/bin_heap.h>
-#include <lemon/fourary_heap.h>
-#include <lemon/kary_heap.h>
 #include <lemon/fib_heap.h>
-#include <lemon/pairing_heap.h>
 #include <lemon/radix_heap.h>
-#include <lemon/binom_heap.h>
 #include <lemon/bucket_heap.h>
 
@@ -93 +90 @@
 void heapSortTest() {
   RangeMap<int> map(test_len, -1);
+
   Heap heap(map);
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -102 +101 @@
   std::sort(v.begin(), v.end());
   for (int i = 0; i < test_len; ++i) {
-    check(v[i] == heap.prio(), "Wrong order in heap sort.");
+    check(v[i] == heap.prio() ,"Wrong order in heap sort.");
     heap.pop();
   }
@@ -114 +113 @@
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -124 +124 @@
   std::sort(v.begin(), v.end());
   for (int i = 0; i < test_len; ++i) {
-    check(v[i] == heap.prio(), "Wrong order in heap increase test.");
+    check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
     heap.pop();
   }
 }
+
+
 
 template <typename Heap>
@@ -143 +145 @@
     if (dijkstra.reached(s)) {
       check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
-             "Error in shortest path tree.");
+             "Error in a shortest path tree!");
     }
   }
@@ -152 +154 @@
       Node s = digraph.source(a);
       check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
-             "Error in shortest path tree.");
+             "Error in a shortest path tree!");
     }
   }
@@ -174 +176 @@
     run();
 
-  // BinHeap
   {
     typedef BinHeap<Prio, ItemIntMap> IntHeap;
@@ -186 +187 @@
   }
 
-  // FouraryHeap
-  {
-    typedef FouraryHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // KaryHeap
-  {
-    typedef KaryHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef KaryHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // FibHeap
   {
     typedef FibHeap<Prio, ItemIntMap> IntHeap;
@@ -222 +198 @@
   }
 
-  // PairingHeap
-  {
-    typedef PairingHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef PairingHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // RadixHeap
   {
     typedef RadixHeap<ItemIntMap> IntHeap;
@@ -246 +209 @@
   }
 
-  // BinomHeap
-  {
-    typedef BinomHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BinomHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // BucketHeap, SimpleBucketHeap
   {
     typedef BucketHeap<ItemIntMap> IntHeap;
@@ -268 +218 @@
     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     dijkstraHeapTest<NodeHeap>(digraph, length, source);
-
-    typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap;
-    heapSortTest<SimpleIntHeap>();
-  }
+  }
+
 
   return 0;

test/maps_test.cc

@@ -24 +24 @@
 #include <lemon/maps.h>
 #include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/dfs.h>
 
 #include "test_tools.h"
@@ -64 +61 @@
 typedef ReadWriteMap<A, bool> BoolWriteMap;
 typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap;
-
-template<typename Map1, typename Map2, typename ItemIt>
-void compareMap(const Map1& map1, const Map2& map2, ItemIt it) {
-  for (; it != INVALID; ++it)
-    check(map1[it] == map2[it], "The maps are not equal");
-}
 
 int main()
@@ -339 +330 @@
   {
     typedef std::vector<int> vec;
-    checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();
-    checkConcept<WriteMap<int, bool>,
-                 LoggerBoolMap<std::back_insert_iterator<vec> > >();
-
     vec v1;
     vec v2(10);
@@ -362 +349 @@
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
-    
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-    Graph gr;
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-    Node n3 = gr.addNode();
-    
-    gr.addArc(n3, n0);
-    gr.addArc(n3, n2);
-    gr.addArc(n0, n2);
-    gr.addArc(n2, n1);
-    gr.addArc(n0, n1);
-    
-    {
-      std::vector<Node> v;
-      dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
-
-      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
-            "Something is wrong with LoggerBoolMap");
-    }
-    {
-      std::vector<Node> v(countNodes(gr));
-      dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
-      
-      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
-            "Something is wrong with LoggerBoolMap");
-    }
-  }
-  
-  // IdMap, RangeIdMap
-  {
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
-    checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
-    checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
-    checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
-    
-    Graph gr;
-    IdMap<Graph, Node> nmap(gr);
-    IdMap<Graph, Arc> amap(gr);
-    RangeIdMap<Graph, Node> nrmap(gr);
-    RangeIdMap<Graph, Arc> armap(gr);
-    
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-    
-    Arc a0 = gr.addArc(n0, n1);
-    Arc a1 = gr.addArc(n0, n2);
-    Arc a2 = gr.addArc(n2, n1);
-    Arc a3 = gr.addArc(n2, n0);
-    
-    check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
-    check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
-    check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
-
-    check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
-    check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
-    check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
-    check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
-
-    check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
-    check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
-    
-    check(nrmap.size() == 3 && armap.size() == 4,
-          "Wrong RangeIdMap::size()");
-
-    check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
-    check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
-    check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
-    
-    check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
-    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
-    check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
-    check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
-
-    check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
-    check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
-    
-    gr.erase(n1);
-    
-    if (nrmap[n0] == 1) nrmap.swap(n0, n2);
-    nrmap.swap(n2, n0);
-    if (armap[a1] == 1) armap.swap(a1, a3);
-    armap.swap(a3, a1);
-    
-    check(nrmap.size() == 2 && armap.size() == 2,
-          "Wrong RangeIdMap::size()");
-
-    check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
-    check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
-    
-    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
-    check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
-
-    check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
-    check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
-  }
-  
-  // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
-  {
-    typedef ListGraph Graph;
-    GRAPH_TYPEDEFS(Graph);
-    
-    checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
-    checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
-    checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
-    checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
-    checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
-    checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
-
-    Graph gr;
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-    
-    gr.addEdge(n0,n1);
-    gr.addEdge(n1,n2);
-    gr.addEdge(n0,n2);
-    gr.addEdge(n2,n1);
-    gr.addEdge(n1,n2);
-    gr.addEdge(n0,n1);
-    
-    for (EdgeIt e(gr); e != INVALID; ++e) {
-      check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
-      check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
-    }
-    
-    compareMap(sourceMap(orienter(gr, constMap<Edge, bool>(true))),
-               targetMap(orienter(gr, constMap<Edge, bool>(false))),
-               EdgeIt(gr));
-
-    typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
-    Digraph dgr(gr, constMap<Edge, bool>(true));
-    OutDegMap<Digraph> odm(dgr);
-    InDegMap<Digraph> idm(dgr);
-    
-    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
-    check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-   
-    gr.addEdge(n2, n0);
-
-    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
-    check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
   }
   
@@ -516 +354 @@
   {
     typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadWriteMap<Node, int>,
-                 CrossRefMap<Graph, Node, int> >();
-    checkConcept<ReadWriteMap<Node, bool>,
-                 CrossRefMap<Graph, Node, bool> >();
-    checkConcept<ReadWriteMap<Node, double>,
-                 CrossRefMap<Graph, Node, double> >();
-    
-    Graph gr;
-    typedef CrossRefMap<Graph, Node, char> CRMap;
-    CRMap map(gr);
-    
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-    
-    map.set(n0, 'A');
-    map.set(n1, 'B');
-    map.set(n2, 'C');
-    
-    check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
-          "Wrong CrossRefMap");
-    check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
-          "Wrong CrossRefMap");
-    check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
-          "Wrong CrossRefMap");
-    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
-          "Wrong CrossRefMap::count()");
-    
-    CRMap::ValueIt it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-    
-    map.set(n2, 'A');
-
-    check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
-          "Wrong CrossRefMap");
-    check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
-    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
-    check(map('C') == INVALID && map.inverse()['C'] == INVALID,
-          "Wrong CrossRefMap");
-    check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,
-          "Wrong CrossRefMap::count()");
-
-    it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&
-          it == map.endValue(), "Wrong value iterator");
-
-    map.set(n0, 'C');
-
-    check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
-          "Wrong CrossRefMap");
-    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
-    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
-    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
-    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
-          "Wrong CrossRefMap::count()");
-
-    it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-  }
-
-  // CrossRefMap
-  {
-    typedef SmartDigraph Graph;
     DIGRAPH_TYPEDEFS(Graph);
 
@@ -613 +384 @@
           it == map.endValue(), "Wrong value iterator");
   }
-  
-  // Iterable bool map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-
-    typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;
-    checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();
-
-    const int num = 10;
-    Graph g;
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Ibm map1(g, true);
-    int n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)], "Wrong TrueIt");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-    n = 0;
-    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
-        ++n;
-    }
-    check(n == num, "Wrong number");
-    check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt");
-    check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false");
-
-    map1[items[5]] = true;
-
-    n = 0;
-    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
-        ++n;
-    }
-    check(n == num, "Wrong number");
-
-    map1[items[num / 2]] = false;
-    check(map1[items[num / 2]] == false, "Wrong map value");
-
-    n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
-        ++n;
-    }
-    check(n == num - 1, "Wrong number");
-
-    n = 0;
-    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
-        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
-        ++n;
-    }
-    check(n == 1, "Wrong number");
-
-    map1[items[0]] = false;
-    check(map1[items[0]] == false, "Wrong map value");
-
-    map1[items[num - 1]] = false;
-    check(map1[items[num - 1]] == false, "Wrong map value");
-
-    n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
-        ++n;
-    }
-    check(n == num - 3, "Wrong number");
-    check(map1.trueNum() == num - 3, "Wrong number");
-
-    n = 0;
-    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
-        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
-        ++n;
-    }
-    check(n == 3, "Wrong number");
-    check(map1.falseNum() == 3, "Wrong number");
-  }
-
-  // Iterable int map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-    typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim;
-
-    checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>();
-
-    const int num = 10;
-    Graph g;
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Iim map1(g);
-    check(map1.size() == 0, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      map1[items[i]] = i;
-    }
-    check(map1.size() == num, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      Iim::ItemIt it(map1, i);
-      check(static_cast<Item>(it) == items[i], "Wrong value");
-      ++it;
-      check(static_cast<Item>(it) == INVALID, "Wrong value");
-    }
-
-    for (int i = 0; i < num; ++i) {
-      map1[items[i]] = i % 2;
-    }
-    check(map1.size() == 2, "Wrong size");
-
-    int n = 0;
-    for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 0, "Wrong value");
-      ++n;
-    }
-    check(n == (num + 1) / 2, "Wrong number");
-
-    for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 1, "Wrong value");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-  }
-
-  // Iterable value map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-    typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm;
-
-    checkConcept<ReadWriteMap<Item, double>, Ivm>();
-
-    const int num = 10;
-    Graph g;
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Ivm map1(g, 0.0);
-    check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size");
-    check(*map1.beginValue() == 0.0, "Wrong value");
-
-    for (int i = 0; i < num; ++i) {
-      map1.set(items[i], static_cast<double>(i));
-    }
-    check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      Ivm::ItemIt it(map1, static_cast<double>(i));
-      check(static_cast<Item>(it) == items[i], "Wrong value");
-      ++it;
-      check(static_cast<Item>(it) == INVALID, "Wrong value");
-    }
-
-    for (Ivm::ValueIt vit = map1.beginValue();
-         vit != map1.endValue(); ++vit) {
-      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
-            "Wrong ValueIt");
-    }
-
-    for (int i = 0; i < num; ++i) {
-      map1.set(items[i], static_cast<double>(i % 2));
-    }
-    check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size");
-
-    int n = 0;
-    for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 0.0, "Wrong value");
-      ++n;
-    }
-    check(n == (num + 1) / 2, "Wrong number");
-
-    for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 1.0, "Wrong value");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-  }
+
   return 0;
 }

test/mip_test.cc

@@ -51 +51 @@
   if (stat ==  MipSolver::OPTIMAL) {
     std::ostringstream sbuf;
-    sbuf << "Wrong optimal value ("<< mip.solValue()
-         <<" instead of " << exp_opt << ")";
+    buf << "Wrong optimal value: the right optimum is " << exp_opt;
     check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
     //+ecvt(exp_opt,2)

test/preflow_test.cc

@@ -95 +95 @@
   PreflowType preflow_test(g, cap, n, n);
   const PreflowType& const_preflow_test = preflow_test;
-  
-  const PreflowType::Elevator& elev = const_preflow_test.elevator();
-  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
-  PreflowType::Tolerance tol = const_preflow_test.tolerance();
-  preflow_test.tolerance(tol);
 
   preflow_test

test/test_tools.h

@@ -38 +38 @@
 ///print something like this (and then exits).
 ///\verbatim file_name.cc:123: error: This is obviously false. \endverbatim
-#define check(rc, msg)                                                  \
-  {                                                                     \
-    if(!(rc)) {                                                         \
-      std::cerr << __FILE__ ":" << __LINE__ << ": error: "              \
-                << msg << std::endl;                                    \
-      abort();                                                          \
-    } else { }                                                          \
-  }                                                                     \
-    
+#define check(rc, msg) \
+  if(!(rc)) { \
+    std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \
+    abort(); \
+  } else { } \
 
 #endif

tools/lemon-0.x-to-1.x.sh

@@ -36 +36 @@
         -e "s/Edge\>/_Ar_c_label_/g"\
         -e "s/\<edge\>/_ar_c_label_/g"\
-        -e "s/_edge\>/__ar_c_label_/g"\
+        -e "s/_edge\>/_ar_c_label_/g"\
         -e "s/Edges\>/_Ar_c_label_s/g"\
         -e "s/\<edges\>/_ar_c_label_s/g"\
-        -e "s/_edges\>/__ar_c_label_s/g"\
+        -e "s/_edges\>/_ar_c_label_s/g"\
         -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\
         -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\
@@ -69 +69 @@
         -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\
         -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\
-        -e "s/\<digraph_adaptor\.h\>/adaptors.h/g"\
-        -e "s/\<digraph_utils\.h\>/core.h/g"\
-        -e "s/\<digraph_reader\.h\>/lgf_reader.h/g"\
-        -e "s/\<digraph_writer\.h\>/lgf_writer.h/g"\
-        -e "s/\<topology\.h\>/connectivity.h/g"\
         -e "s/DigraphToEps/GraphToEps/g"\
         -e "s/digraphToEps/graphToEps/g"\