Index: demo/grid_graph_demo.cc
===================================================================
--- demo/grid_graph_demo.cc	(revision 1693)
+++ demo/grid_graph_demo.cc	(revision 1763)
@@ -46,5 +46,5 @@
   for (GridGraph::Node node = stop; 
        node != start; node = bfs.predNode(node)) {
-    path[bfs.pred(node)] = true;
+    path[bfs.predEdge(node)] = true;
   }
   
Index: lemon/belmann_ford.h
===================================================================
--- lemon/belmann_ford.h	(revision 1754)
+++ lemon/belmann_ford.h	(revision 1763)
@@ -504,6 +504,6 @@
 	p.clear();
 	typename Path::Builder b(p);
-	for(b.setStartNode(t);pred(t)!=INVALID;t=predNode(t))
-	  b.pushFront(pred(t));
+	for(b.setStartNode(t);predEdge(t)!=INVALID;t=predNode(t))
+	  b.pushFront(predEdge(t));
 	b.commit();
 	return true;
@@ -530,5 +530,5 @@
     /// this function.
     /// \todo predEdge could be a better name.
-    Edge pred(Node v) const { return (*_pred)[v]; }
+    Edge predEdge(Node v) const { return (*_pred)[v]; }
 
     /// \brief Returns the 'previous node' of the shortest path tree.
@@ -538,5 +538,5 @@
     /// the root to \c /v. It is INVALID if \c v is unreachable from the root 
     /// or if \c v=s. The shortest path tree used here is equal to the 
-    /// shortest path tree used in \ref pred().  \pre \ref run() must be 
+    /// shortest path tree used in \ref predEdge().  \pre \ref run() must be 
     /// called before using this function.
     Node predNode(Node v) const { 
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1761)
+++ lemon/bfs.h	(revision 1763)
@@ -621,6 +621,6 @@
 	p.clear();
 	typename P::Builder b(p);
-	for(b.setStartNode(t);pred(t)!=INVALID;t=predNode(t))
-	  b.pushFront(pred(t));
+	for(b.setStartNode(t);predEdge(t)!=INVALID;t=predNode(t))
+	  b.pushFront(predEdge(t));
 	b.commit();
 	return true;
@@ -649,5 +649,5 @@
     ///this function.
     ///\todo predEdge could be a better name.
-    Edge pred(Node v) const { return (*_pred)[v];}
+    Edge predEdge(Node v) const { return (*_pred)[v];}
 
     ///Returns the 'previous node' of the shortest path tree.
@@ -660,5 +660,5 @@
     ///if \c v itself a root.
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred().
+    ///tree used in \ref predEdge().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1761)
+++ lemon/dfs.h	(revision 1763)
@@ -643,6 +643,6 @@
 	p.clear();
 	typename P::Builder b(p);
-	for(b.setStartNode(t);pred(t)!=INVALID;t=predNode(t))
-	  b.pushFront(pred(t));
+	for(b.setStartNode(t);predEdge(t)!=INVALID;t=predNode(t))
+	  b.pushFront(predEdge(t));
 	b.commit();
 	return true;
@@ -671,5 +671,5 @@
     ///this function.
     ///\todo predEdge could be a better name.
-    Edge pred(Node v) const { return (*_pred)[v];}
+    Edge predEdge(Node v) const { return (*_pred)[v];}
 
     ///Returns the 'previous node' of the %DFS tree.
@@ -682,5 +682,5 @@
     ///if \c v itself a root.
     ///The %DFS tree used here is equal to the %DFS
-    ///tree used in \ref pred().
+    ///tree used in \ref predEdge().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1761)
+++ lemon/dijkstra.h	(revision 1763)
@@ -734,6 +734,6 @@
 	p.clear();
 	typename P::Builder b(p);
-	for(b.setStartNode(t);pred(t)!=INVALID;t=predNode(t))
-	  b.pushFront(pred(t));
+	for(b.setStartNode(t);predEdge(t)!=INVALID;t=predNode(t))
+	  b.pushFront(predEdge(t));
 	b.commit();
 	return true;
@@ -760,5 +760,5 @@
     ///this function.
     ///\todo predEdge could be a better name.
-    Edge pred(Node v) const { return (*_pred)[v]; }
+    Edge predEdge(Node v) const { return (*_pred)[v]; }
 
     ///Returns the 'previous node' of the shortest path tree.
@@ -768,5 +768,5 @@
     ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
     ///\c v=s. The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred().  \pre \ref run() must be called before
+    ///tree used in \ref predEdge().  \pre \ref run() must be called before
     ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
Index: lemon/floyd_warshall.h
===================================================================
--- lemon/floyd_warshall.h	(revision 1757)
+++ lemon/floyd_warshall.h	(revision 1763)
@@ -489,7 +489,7 @@
 	p.clear();
 	typename Path::Builder b(target);
-	for(b.setStartNode(target); pred(source, target) != INVALID;
+	for(b.setStartNode(target); predEdge(source, target) != INVALID;
 	    target = predNode(target)) {
-	  b.pushFront(pred(source, target));
+	  b.pushFront(predEdge(source, target));
 	}
 	b.commit();
@@ -519,5 +519,5 @@
     /// \pre \ref run() must be called before using this function.
     /// \todo predEdge could be a better name.
-    Edge pred(Node root, Node node) const { 
+    Edge predEdge(Node root, Node node) const { 
       return (*_pred)(root, node); 
     }
@@ -530,5 +530,5 @@
     /// INVALID if \c node is unreachable from the root or if \c node=root. 
     /// The shortest path tree used here is equal to the 
-    /// shortest path tree used in \ref pred().  
+    /// shortest path tree used in \ref predEdge().  
     /// \pre \ref run() must be called before using this function.
     Node predNode(Node root, Node node) const { 
Index: lemon/johnson.h
===================================================================
--- lemon/johnson.h	(revision 1757)
+++ lemon/johnson.h	(revision 1763)
@@ -510,5 +510,5 @@
 	    _dist->set(it, jt, dijkstra.dist(jt) + 
 		       potential[jt] - potential[it]);
-	    _pred->set(it, jt, dijkstra.pred(jt));
+	    _pred->set(it, jt, dijkstra.predEdge(jt));
 	  } else {
 	    _dist->set(it, jt, OperationTraits::infinity());
@@ -635,7 +635,7 @@
 	p.clear();
 	typename Path::Builder b(target);
-	for(b.setStartNode(target); pred(source, target) != INVALID;
+	for(b.setStartNode(target); predEdge(source, target) != INVALID;
 	    target = predNode(target)) {
-	  b.pushFront(pred(source, target));
+	  b.pushFront(predEdge(source, target));
 	}
 	b.commit();
@@ -665,5 +665,5 @@
     /// \pre \ref run() must be called before using this function.
     /// \todo predEdge could be a better name.
-    Edge pred(Node root, Node node) const { 
+    Edge predEdge(Node root, Node node) const { 
       return (*_pred)(root, node); 
     }
@@ -676,5 +676,5 @@
     /// INVALID if \c node is unreachable from the root or if \c node=root. 
     /// The shortest path tree used here is equal to the 
-    /// shortest path tree used in \ref pred().  
+    /// shortest path tree used in \ref predEdge().  
     /// \pre \ref run() must be called before using this function.
     Node predNode(Node root, Node node) const { 
Index: lemon/min_cost_flow.h
===================================================================
--- lemon/min_cost_flow.h	(revision 1527)
+++ lemon/min_cost_flow.h	(revision 1763)
@@ -152,5 +152,5 @@
 	ResGraphEdge e;
 	while (n!=s){
-	  e = dijkstra.pred(n);
+	  e = dijkstra.predEdge(n);
 	  n = dijkstra.predNode(n);
 	  res_graph.augment(e,1);
Index: lemon/topology.h
===================================================================
--- lemon/topology.h	(revision 1750)
+++ lemon/topology.h	(revision 1763)
@@ -111,4 +111,7 @@
   /// Find the connected components of an undirected graph.
   ///
+  /// \image html connected_components.png
+  /// \image latex connected_components.eps "Connected components" width=\textwidth
+  ///
   /// \param g The graph. In must be undirected.
   /// \retval comp A writable node map. The values will be set from 0 to
@@ -117,4 +120,5 @@
   /// set continuously.
   /// \return The number of components
+  ///
   template <class UndirGraph, class NodeMap>
   int connectedComponents(const UndirGraph &graph, NodeMap &compMap) {
@@ -349,4 +353,7 @@
   /// when there are directed paths between them in both direction.
   ///
+  /// \image html strongly_connected_components.png
+  /// \image latex strongly_connected_components.eps "Strongly connected components" width=\textwidth
+  ///
   /// \param g The graph.
   /// \retval comp A writable node map. The values will be set from 0 to
@@ -355,4 +362,5 @@
   /// will be set continuously.
   /// \return The number of components
+  ///
   template <typename Graph, typename NodeMap>
   int stronglyConnectedComponents(const Graph& graph, NodeMap& compMap) {
@@ -747,4 +755,7 @@
   /// when they are on same circle.
   ///
+  /// \image html node_biconnected_components.png
+  /// \image latex node_biconnected_components.eps "Node biconnected components" width=\textwidth
+  ///
   /// \param graph The graph.
   /// \retval comp A writable undir edge map. The values will be set from 0 to
@@ -753,4 +764,5 @@
   /// will be set continuously.
   /// \return The number of components.
+  ///
   template <typename UndirGraph, typename UndirEdgeMap>
   int nodeBiconnectedComponents(const UndirGraph& graph, 
@@ -1070,4 +1082,7 @@
   /// connected at least two edge-disjoint paths.
   ///
+  /// \image html edge_biconnected_components.png
+  /// \image latex edge_biconnected_components.eps "Edge biconnected components" width=\textwidth
+  ///
   /// \param graph The graph.
   /// \retval comp A writable node map. The values will be set from 0 to
@@ -1076,4 +1091,5 @@
   /// will be set continuously.
   /// \return The number of components.
+  ///
   template <typename UndirGraph, typename NodeMap>
   int edgeBiconnectedComponents(const UndirGraph& graph, NodeMap& compMap) { 
@@ -1323,5 +1339,5 @@
 	  Node target = graph.target(edge);
 	  if (dfs.reached(target) && 
-	      dfs.pred(source) != graph.oppositeEdge(edge)) {
+	      dfs.predEdge(source) != graph.oppositeEdge(edge)) {
 	    return false;
 	  }
@@ -1354,5 +1370,5 @@
       Node target = graph.target(edge);
       if (dfs.reached(target) && 
-	  dfs.pred(source) != graph.oppositeEdge(edge)) {
+	  dfs.predEdge(source) != graph.oppositeEdge(edge)) {
 	return false;
       }
Index: test/all_pairs_shortest_path_test.cc
===================================================================
--- test/all_pairs_shortest_path_test.cc	(revision 1745)
+++ test/all_pairs_shortest_path_test.cc	(revision 1763)
@@ -89,13 +89,13 @@
  	  check(johnson.dist(it, jt) == 
 		johnson.dist(it, johnson.predNode(it, jt)) +
-		length[johnson.pred(it, jt)],
+		length[johnson.predEdge(it, jt)],
 		"Wrong edge in all pairs shortest path");
  	  check(fibJohnson.dist(it, jt) == 
 		fibJohnson.dist(it, fibJohnson.predNode(it, jt)) +
-		length[fibJohnson.pred(it, jt)],
+		length[fibJohnson.predEdge(it, jt)],
 		"Wrong edge in all pairs shortest path");
 	  check(floyd.dist(it, jt) == 
 		floyd.dist(it, floyd.predNode(it, jt)) +
-		length[floyd.pred(it, jt)],
+		length[floyd.predEdge(it, jt)],
 		"Wrong edge in all pairs shortest path");
 	}
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 1435)
+++ test/bfs_test.cc	(revision 1763)
@@ -51,5 +51,5 @@
   
   l  = bfs_test.dist(n);
-  e  = bfs_test.pred(n);
+  e  = bfs_test.predEdge(n);
   n  = bfs_test.predNode(n);
   d  = bfs_test.distMap();
@@ -122,6 +122,6 @@
   for(NodeIt v(G); v==INVALID; ++v) {
     check(bfs_test.reached(v),"Each node should be reached.");
-    if ( bfs_test.pred(v)!=INVALID ) {
-      Edge e=bfs_test.pred(v);
+    if ( bfs_test.predEdge(v)!=INVALID ) {
+      Edge e=bfs_test.predEdge(v);
       Node u=G.source(e);
       check(u==bfs_test.predNode(v),"Wrong tree.");
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 1435)
+++ test/dfs_test.cc	(revision 1763)
@@ -51,5 +51,5 @@
   
   l  = dfs_test.dist(n);
-  e  = dfs_test.pred(n);
+  e  = dfs_test.predEdge(n);
   n  = dfs_test.predNode(n);
   d  = dfs_test.distMap();
@@ -112,6 +112,6 @@
   for(NodeIt v(G); v!=INVALID; ++v) {
     check(dfs_test.reached(v),"Each node should be reached.");
-    if ( dfs_test.pred(v)!=INVALID ) {
-      Edge e=dfs_test.pred(v);
+    if ( dfs_test.predEdge(v)!=INVALID ) {
+      Edge e=dfs_test.predEdge(v);
       Node u=G.source(e);
       check(u==dfs_test.predNode(v),"Wrong tree.");
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 1435)
+++ test/dijkstra_test.cc	(revision 1763)
@@ -55,5 +55,5 @@
 
   l  = dijkstra_test.dist(n);
-  e  = dijkstra_test.pred(n);
+  e  = dijkstra_test.predEdge(n);
   n  = dijkstra_test.predNode(n);
   d  = dijkstra_test.distMap();
@@ -136,6 +136,6 @@
   for(NodeIt v(G); v!=INVALID; ++v){
     check(dijkstra_test.reached(v),"Each node should be reached.");
-    if ( dijkstra_test.pred(v)!=INVALID ) {
-      Edge e=dijkstra_test.pred(v);
+    if ( dijkstra_test.predEdge(v)!=INVALID ) {
+      Edge e=dijkstra_test.predEdge(v);
       Node u=G.source(e);
       check(u==dijkstra_test.predNode(v),"Wrong tree.");
Index: test/heap_test.h
===================================================================
--- test/heap_test.h	(revision 1745)
+++ test/heap_test.h	(revision 1763)
@@ -94,6 +94,6 @@
 
   for(NodeIt v(graph); v!=INVALID; ++v) {
-    if ( dijkstra.reached(v) && dijkstra.pred(v) != INVALID ) {
-      Edge e=dijkstra.pred(v);
+    if ( dijkstra.reached(v) && dijkstra.predEdge(v) != INVALID ) {
+      Edge e=dijkstra.predEdge(v);
       Node u=graph.source(e);
       check( dijkstra.dist(v) - dijkstra .dist(u) == length[e],
