Changeset 2084:59769591eb60 in lemon-0.x

Timestamp:

05/15/06 11:49:51 (17 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2749

Message:

Documentation improvements

Rearrangements:

IO modules
Algorithms

New documentation:

SwapBpUGraphAdaptor

Demos:

strongly_connected_orientation.cc

Benchmarks:

swap_bipartite_bench.cc

Files:

• benchmark/Makefile.am (modified) (2 diffs)
• benchmark/swap_bipartite_bench.cc (added)
• demo/Makefile.am (modified) (2 diffs)
• demo/disjoint_paths.cc (deleted)
• demo/disjoint_paths.lgf (deleted)
• demo/disjoint_paths_demo.cc (added)
• demo/disjoint_paths_demo.lgf (added)
• demo/strongly_connected_orientation.cc (added)
• demo/strongly_connected_orientation.lgf (added)
• doc/graph-adaptors.dox (modified) (3 diffs)
• doc/groups.dox (modified) (10 diffs)
• doc/images/swap_test.eps (added)
• doc/images/swap_test.png (added)
• lemon/bpugraph_adaptor.h (modified) (2 diffs)
• lemon/eps.h (modified) (2 diffs)
• lemon/graph_adaptor.h (modified) (3 diffs)
• lemon/graph_reader.h (modified) (2 diffs)
• lemon/graph_to_eps.h (modified) (4 diffs)
• lemon/kruskal.h (modified) (1 diff)
• lemon/lemon_reader.h (modified) (5 diffs)
• lemon/lemon_writer.h (modified) (10 diffs)
• lemon/matrix_maps.h (modified) (6 diffs)
• lemon/path.h (modified) (1 diff)
• lemon/radix_sort.h (modified) (3 diffs)
• lemon/ugraph_adaptor.h (modified) (9 diffs)

benchmark/Makefile.am

@@ -3 +3 @@
 noinst_HEADERS = bench_tools.h
 
-noinst_PROGRAMS = graph-bench hcube bfs-bench radix_sort-bench
+noinst_PROGRAMS = \
+        graph-bench \
+        hcube \
+        swap_bipartite_bench \
+        bfs-bench \
+        swap_bipartite_bench
 
 graph_bench_SOURCES = graph-bench.cc
@@ -12 +17 @@
 
 radix_sort_bench_SOURCES = radix_sort-bench.cc
+
+swap_bipartite_bench_SOURCES = swap_bipartite_bench.cc

demo/Makefile.am

@@ -20 +20 @@
         topology_demo \
         simann_maxcut_demo \
-        disjoint_paths_demo
+        disjoint_paths_demo \
+        strongly_connected_orientation
 
 if HAVE_GLPK
@@ -69 +70 @@
 simann_maxcut_demo_SOURCES = simann_maxcut_demo.cc
 
-disjoint_paths_demo_SOURCES = disjoint_paths.cc
+disjoint_paths_demo_SOURCES = disjoint_paths_demo.cc
+
+strongly_connected_orientation_SOURCES = strongly_connected_orientation.cc

doc/graph-adaptors.dox

@@ -37 +37 @@
    \code
    ListGraph g;
-   RevGraphAdaptor<ListGraph> rgw(g);
-   int result=algorithm(rgw);
+   RevGraphAdaptor<ListGraph> rga(g);
+   int result=algorithm(rga);
    \endcode
    After running the algorithm, the original graph \c g 
@@ -59 +59 @@
    meaningless. This means that the concepts that they are models of depend 
    on the graph adaptor, and the wrapped graph(s). 
-   If an edge of \c rgw is deleted, this is carried out by 
+   If an edge of \c rga is deleted, this is carried out by 
    deleting the corresponding edge of \c g, thus the adaptor modifies the 
    original graph. 
@@ -74 +74 @@
    \code
    int algorithm1(const ListGraph& g) {
-   RevGraphAdaptor<const ListGraph> rgw(g);
-   return algorithm2(rgw);
+   RevGraphAdaptor<const ListGraph> rga(g);
+   return algorithm2(rga);
    }
    \endcode

doc/groups.dox

@@ -15 +15 @@
 and thereafter the program code can be made efficient by small modifications. 
 
-The most efficient implementation of diverse applications require the usage of different physical graph implementations. These differences appear in the size of 
-graph we require to handle, memory or time usage limitations or in 
-the set of operations through which the graph can be accessed. 
-LEMON provides several physical graph structures to meet the 
-diverging requirements of the possible users. 
-In order to save on running time or on memory usage, some structures may 
-fail to provide some graph features like edge or node deletion.
+The most efficient implementation of diverse applications require the
+usage of different physical graph implementations. These differences
+appear in the size of graph we require to handle, memory or time usage
+limitations or in the set of operations through which the graph can be
+accessed.  LEMON provides several physical graph structures to meet
+the diverging requirements of the possible users.  In order to save on
+running time or on memory usage, some structures may fail to provide
+some graph features like edge or node deletion.
 
 Alteration of standard containers need a very limited number of 
@@ -77 +78 @@
 
 Most of them are \ref lemon::concept::ReadMap "ReadMap"s. They can
-make arithmetic oprerations between one or two maps (negation, scalig,
+make arithmetic oprerations between one or two maps (negation, scaling,
 addition, multiplication etc.) or e.g. convert a map to another one
 of different Value type.
@@ -87 +88 @@
 \brief Two dimensional data storages.
 
-Two dimensional
-data storages.
-*/
-
+Two dimensional data storages.
+*/
+
+/**
+@defgroup paths Path Structures
+@ingroup datas
+\brief Path structures implemented in LEMON.
+
+LEMON provides flexible data structures
+to work with paths.
+
+All of them have the same interface, especially they can be built or extended
+using a standard Builder subclass. This make is easy to have e.g. the Dijkstra
+algorithm to store its result in any kind of path structure.
+
+\sa lemon::concept::Path
+
+*/
 
 /**
@@ -111 +126 @@
 
 /**
-@defgroup galgs Graph Algorithms
-\brief This group describes the several graph algorithms
+@defgroup algs Algorithms
+\brief This group describes the several algorithms
 implemented in LEMON.
 
-This group describes the several graph algorithms
+This group describes the several algorithms
 implemented in LEMON.
 */
@@ -121 +136 @@
 /**
 @defgroup gutils General Graph Utilities
-@ingroup galgs
+@ingroup algs
 \brief This group describes some simple general graph utilities.
 
 This group describes some simple general graph utilities.
+*/
+
+/**
+@defgroup flowalgs Path and Flow Algorithms
+@ingroup algs
+\brief This group describes the algorithms
+for finding paths and flows in graphs.
+
+This group describes the algorithms
+for finding paths and flows in graphs.
+
+\image html flow.png
+\image latex flow.eps "Graph flow" width=\textwidth
+*/
+
+/**
+@defgroup topology Topology related algorithms
+@ingroup algs
+\brief This group describes the algorithms
+for discover the topology of the graphs.
+
+This group describes the algorithms
+for discover the topology of the graphs.
+
+\image html edge_biconnected_components.png
+\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
+
+*/
+
+/**
+@defgroup matching Matching algorithms in graphs and bipartite graphs
+@ingroup algs
+\brief This group describes the algorithms
+for find matchings in graphs and bipartite graphs.
+
+This group provides some algorithm objects and function
+to calculate matchings in graphs and bipartite graphs.
+
+\image html bipartite_matching.png
+\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
+
+*/
+
+/**
+@defgroup spantree Minimum Cost Spanning Tree Algorithms
+@ingroup algs
+\brief This group containes the algorithms for finding a minimum cost spanning
+tree in a graph
+
+This group containes the algorithms for finding a minimum cost spanning
+tree in a graph
+*/
+
+
+/**
+@defgroup auxalg Auxiliary Algorithms
+@ingroup algs
+\brief Some algorithms implemented in LEMON.
+
+This group describes the algorithms in LEMON in order to make 
+it easier to implement complex algorithms.
+
 */
 
@@ -135 +212 @@
 implemented in LEMON.
 
-*/
-
-/**
-@defgroup flowalgs Path and Flow Algorithms
-@ingroup galgs
-\brief This group describes the algorithms
-for finding paths and flows in graphs.
-
-This group describes the algorithms
-for finding paths and flows in graphs.
-
-\image html flow.png
-\image latex flow.eps "Graph flow" width=\textwidth
-*/
-
-/**
-@defgroup topology Topology related algorithms
-@ingroup galgs
-\brief This group describes the algorithms
-for discover the topology of the graphs.
-
-This group describes the algorithms
-for discover the topology of the graphs.
-
-\image html edge_biconnected_components.png
-\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
-
-*/
-
-/**
-@defgroup matching Matching algorithms in graphs and bipartite graphs
-@ingroup galgs
-\brief This group describes the algorithms
-for find matchings in graphs and bipartite graphs.
-
-This group provides some algorithm objects and function
-to calculate matchings in graphs and bipartite graphs.
-
-\image html bipartite_matching.png
-\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
-
-*/
-
-/**
-@defgroup exceptions Exceptions
-This group contains the exceptions thrown by LEMON library
 */
 
@@ -198 +229 @@
 /**
 @defgroup io_group Input-Output
-Here you can find tools for imporing and exporting graphs and graph related
-data
+\brief Several Graph Input-Output methods
+
+Here you can find tools for importing and exporting graphs 
+and graph related data. Now it supports the LEMON format, the
+dimacs format and the encapsulated postscript format.
+*/
+
+/**
+@defgroup lemon_io Lemon Input-Output
+@ingroup io_group
+\brief Reading and writing LEMON format
+
+Methods for reading and writing LEMON format. More about this
+format you can find on the \ref graph-io-page "Graph Input-Output"
+tutorial pages.
+
 */
 
 /**
 @defgroup section_io Section readers and writers
-@ingroup io_group
+@ingroup lemon_io
 \brief Section readers and writers for lemon Input-Output.
 
@@ -213 +258 @@
 /**
 @defgroup item_io Item Readers and Writers
-@ingroup io_group
+@ingroup lemon_io
 \brief Item readers and writers for lemon Input-Output.
 
@@ -222 +267 @@
 
 /**
+@defgroup eps_io Postscript exporting
+@ingroup io_group
+\brief General EPS drawer and graph exporter
+
+This group contains general EPS drawing methods and special
+graph exporting tools. 
+*/
+
+/**
+@defgroup exceptions Exceptions
+This group contains the exceptions thrown by LEMON library
+*/
+
+/**
 @defgroup concept Concepts
 \brief Skeleton classes and concept checking classes
@@ -234 +293 @@
 
 */
+
 
 /**

lemon/bpugraph_adaptor.h

@@ -410 +410 @@
   ///
   /// Bipartite graph adaptor which swaps the two nodeset. The adaptor's
-  /// a-nodeset will be the original graph's b-nodeset and the adaptor's
-  /// b-nodeset will be the original graph's a-nodeset. 
+  /// anode-set will be the original graph's bnode-set and the adaptor's
+  /// bnode-set will be the original graph's anode-set.
+  ///
+  /// As example look at an algorithm what can be sped up with the
+  /// swap bipartite undirected graph adaptor. If we want to find the
+  /// maximum matching in the bipartite graph then it will be not changed
+  /// if we swap the two nodesets. But the algorithm use the two nodeset
+  /// different way. If we swap the nodesets it provides different
+  /// running time. We run a test on random bipartite graphs with
+  /// different rate of the anode-set size and bnode-set size.
+  /// We always made graphs with 10000 nodes and 20000 edges and we
+  /// computed the maximum cardinality matching with the Hopcroft-Karp 
+  /// algorithm.
+  ///
+  /// The next diagram shows the running time of the tests. If the anode-set
+  /// is smaller than the bnode-set the running time is better than with 
+  /// the swapped graph. Other conclusion is that the running time
+  /// is greater when the two nodesets size are nearly equal. 
+  ///
+  /// \image html swap_test.png
+  /// \image latex swap_test.eps "Swapping nodesets" width=\textwidth
+  /// 
+  /// The next part shows how can we swap the two nodeset:
+  ///
+  ///\code
+  /// typedef SwapBpUGraphAdaptor<BpUGraph> SBpUGraph;
+  /// SBpUGraph sbpugraph(bpugraph);
+  /// MaxBipartiteMatching<SBpUGraph> sbpumatch(sbpugraph);
+  ///\endcode
   template <typename _BpUGraph>
   class SwapBpUGraphAdaptor 
@@ -426 +453 @@
   public:
 
+    /// \brief Construct a swapped graph.
+    ///
+    /// Construct a swapped graph.
     explicit SwapBpUGraphAdaptor(Graph& _graph) { setGraph(_graph); }
 

lemon/eps.h

@@ -27 +27 @@
 #include<lemon/xy.h>
 
-  ///\ingroup io_group
+  ///\ingroup eps_io
   ///\file
   ///\brief Simple tool to create \c .eps files
@@ -35 +35 @@
 namespace lemon {
   
-  ///\ingroup io_group
+  ///\ingroup eps_io
   ///\brief A simple tool to create \c .eps files
   ///

lemon/graph_adaptor.h

@@ -265 +265 @@
   /// implements the graph obtained from \c g by 
   /// reversing the orientation of its edges.
+  ///
+  /// A good example of using RevGraphAdaptor is to decide that the
+  /// directed graph is wheter strongly connected or not. If from one
+  /// node each node is reachable and from each node is reachable this
+  /// node then and just then the graph is strongly connected. Instead of
+  /// this condition we use a little bit different. From one node each node
+  /// ahould be reachable in the graph and in the reversed graph. Now this
+  /// condition can be checked with the Dfs algorithm class and the
+  /// RevGraphAdaptor algorithm class.
+  ///
+  /// And look at the code:
+  ///
+  ///\code
+  /// bool stronglyConnected(const Graph& graph) {
+  ///   if (NodeIt(graph) == INVALID) return true;
+  ///   Dfs<Graph> dfs(graph);
+  ///   dfs.run(NodeIt(graph));
+  ///   for (NodeIt it(graph); it != INVALID; ++it) {
+  ///     if (!dfs.reached(it)) {
+  ///       return false;
+  ///     }
+  ///   }
+  ///   typedef RevGraphAdaptor<const Graph> RGraph;
+  ///   RGraph rgraph(graph);
+  ///   DfsVisit<RGraph> rdfs(rgraph);
+  ///   rdfs.run(NodeIt(graph));
+  ///   for (NodeIt it(graph); it != INVALID; ++it) {
+  ///     if (!rdfs.reached(it)) {
+  ///       return false;
+  ///     }
+  ///   }
+  ///   return true;
+  /// }
+  ///\endcode
   template<typename _Graph>
   class RevGraphAdaptor : 
@@ -2388 +2422 @@
   ///
   /// The second solution contains just 3 disjoint paths while the first 4.
-  /// The full code can be found in the \ref disjoint_paths.cc demo file.
+  /// The full code can be found in the \ref disjoint_paths_demo.cc demo file.
   ///
   /// This graph adaptor is fully conform to the 
@@ -2588 +2622 @@
   };
 
+  /// \brief Just gives back a split graph adaptor
+  ///
+  /// Just gives back a split graph adaptor
+  template<typename Graph>
+  SplitGraphAdaptor<Graph>
+  splitGraphAdaptor(const Graph& graph) {
+    return SplitGraphAdaptor<Graph>(graph);
+  }
+
 
 } //namespace lemon

lemon/graph_reader.h

@@ -17 +17 @@
  */
 
-///\ingroup io_group
+///\ingroup lemon_io
 ///\file
 ///\brief Lemon Graph Format reader.
@@ -31 +31 @@
 namespace lemon {
 
-  /// \addtogroup io_group
+  /// \addtogroup lemon_io
   /// @{
 

lemon/graph_to_eps.h

@@ -42 +42 @@
 
 
-///\ingroup io_group
+///\ingroup eps_io
 ///\file
 ///\brief Simple graph drawer
@@ -1043 +1043 @@
 ///Generates an EPS file from a graph
 
-///\ingroup io_group
+///\ingroup eps_io
 ///Generates an EPS file from a graph.
 ///\param g is a reference to the graph to be printed
@@ -1072 +1072 @@
 ///Generates an EPS file from a graph
 
-///\ingroup io_group
+///\ingroup eps_io
 ///This function does the same as
 ///\ref graphToEps(G &g,std::ostream& os)
@@ -1088 +1088 @@
 ///Generates an EPS file from a graph
 
-///\ingroup io_group
+///\ingroup eps_io
 ///This function does the same as
 ///\ref graphToEps(G &g,std::ostream& os)

lemon/kruskal.h

@@ -25 +25 @@
 #include <lemon/bits/utility.h>
 #include <lemon/bits/traits.h>
-
-/**
-@defgroup spantree Minimum Cost Spanning Tree Algorithms
-@ingroup galgs
-\brief This group containes the algorithms for finding a minimum cost spanning
-tree in a graph
-
-This group containes the algorithms for finding a minimum cost spanning
-tree in a graph
-*/
 
 ///\ingroup spantree

lemon/lemon_reader.h

@@ -17 +17 @@
  */
 
-///\ingroup io_group
+///\ingroup lemon_io
 ///\file
 ///\brief Lemon Format reader.
@@ -457 +457 @@
   }
 
-  /// \ingroup io_group
+  /// \ingroup lemon_io
   /// \brief Lemon Format reader class.
   /// 
@@ -524 +524 @@
       char_type* eptr() { return _eptr; }
 
-      int blen() { return _eptr - _base; }
-
-      void setb(char_type* buf, int len) {
+      int_type blen() { return _eptr - _base; }
+
+      void setb(char_type* buf, int_type len) {
         _base = buf;
         _eptr = buf + len;
@@ -582 +582 @@
       }
 
-      virtual int underflow() {
+      virtual int_type underflow() {
         char c;
         if (_is.read(&c, 1)) {
@@ -613 +613 @@
       }
 
-      virtual int sync() {
+      virtual int_type sync() {
         return EOF;
       }

lemon/lemon_writer.h

@@ -17 +17 @@
  */
 
-///\ingroup io_group
+///\ingroup lemon_io
 ///\file
 ///\brief Lemon Format writer.
@@ -258 +258 @@
   }
 
-  /// \ingroup io_group
+  /// \ingroup lemon_io
   /// \brief Lemon Format writer class.
   /// 
@@ -311 +311 @@
       virtual std::string header() = 0;
 
-      /// \brief  Writer function of the section.
+      /// \brief Writer function of the section.
       ///
       /// Write the content of the section.
       virtual void write(std::ostream& os) = 0;
+      
+      /// \brief Gives back true when the section should be written.
+      ///
+      /// Gives back true when the section should be written.
+      virtual bool valid() { return true; }
     };
 
@@ -356 +361 @@
       SectionWriters::iterator it;
       for (it = writers.begin(); it != writers.end(); ++it) {
-        *os << (*it)->header() << std::endl;
-        (*it)->write(*os);
+        if ((*it)->valid()) {
+          *os << (*it)->header() << std::endl;
+          (*it)->write(*os);
+        }
       }
       *os << "@end" << std::endl;
@@ -465 +472 @@
     virtual void write(std::ostream& os) {
       for (int i = 0; i < (int)writers.size(); ++i) {
-        if (writers[i].first == "label" || (writers[i].first == "id" && labelMap == 0)) {
+        if (writers[i].first == "label") {
           labelMap = writers[i].second;
           forceLabelMap = false;
@@ -637 +644 @@
       }
       for (int i = 0; i < (int)writers.size(); ++i) {
-        if (writers[i].first == "label" || (writers[i].first == "id" && labelMap == 0)) {
+        if (writers[i].first == "label") {
           labelMap = writers[i].second;
           forceLabelMap = false;
@@ -1009 +1016 @@
       }
     }
+
+    /// \brief Gives back true when the section should be written.
+    ///
+    /// Gives back true when the section should be written.
+    virtual bool valid() { return !writers.empty(); }
     
   private:
@@ -1088 +1100 @@
       }
     }
+
+    /// \brief Gives back true when the section should be written.
+    ///
+    /// Gives back true when the section should be written.
+    virtual bool valid() { return !writers.empty(); }
     
   private:
@@ -1190 +1207 @@
       }
     }
+
+    /// \brief Gives back true when the section should be written.
+    ///
+    /// Gives back true when the section should be written.
+    virtual bool valid() { 
+      return !uEdgeWriters.empty() || !edgeWriters.empty(); 
+    }
     
   private:
@@ -1289 +1313 @@
     }    
 
+    /// \brief Gives back true when the section should be written.
+    ///
+    /// Gives back true when the section should be written.
+    virtual bool valid() { return !writers.empty(); }
+
   private:
     std::string name;

lemon/matrix_maps.h

@@ -48 +48 @@
 
 
+    /// \brief Constructor of the row map
+    ///
+    /// Constructor of the row map.
     MatrixRowMap(MatrixMap& _matrix, typename MatrixMap::FirstKey _row) 
       : matrix(_matrix), row(_row) {}
@@ -92 +95 @@
 
 
+    /// \brief Constructor of the row map
+    ///
+    /// Constructor of the row map.
     ConstMatrixRowMap(const MatrixMap& _matrix, 
                       typename MatrixMap::FirstKey _row) 
@@ -109 +115 @@
   };
 
+  /// \ingroup matrices
+  ///
   /// \brief Gives back a row view of the matrix map
   ///
-  /// \ingroup matrices
   /// Gives back a row view of the matrix map.
   ///
+  /// \sa MatrixRowMap
+  /// \sa ConstMatrixRowMap
   template <typename MatrixMap>
   MatrixRowMap<MatrixMap> matrixRowMap(MatrixMap& matrixMap,
@@ -138 +147 @@
     typedef typename MatrixMap::Value Value;
 
+    /// \brief Constructor of the column map
+    ///
+    /// Constructor of the column map.
     MatrixColMap(MatrixMap& _matrix, typename MatrixMap::SecondKey _col) 
       : matrix(_matrix), col(_col) {}
@@ -181 +193 @@
     typedef typename MatrixMap::Value Value;
 
+    /// \brief Constructor of the column map
+    ///
+    /// Constructor of the column map.
     ConstMatrixColMap(const MatrixMap& _matrix, 
                       typename MatrixMap::SecondKey _col) 
@@ -198 +213 @@
   };
 
+  /// \ingroup matrices
+  ///
   /// \brief Gives back a column view of the matrix map
   ///
-  /// \ingroup matrices
   /// Gives back a column view of the matrix map.
   ///
+  /// \sa MatrixColMap
+  /// \sa ConstMatrixColMap
   template <typename MatrixMap>
   MatrixColMap<MatrixMap> matrixColMap(MatrixMap& matrixMap,

lemon/path.h

@@ -17 +17 @@
  */
 
-/**
-@defgroup paths Path Structures
-@ingroup datas
-\brief Path structures implemented in LEMON.
-
-LEMON provides flexible data structures
-to work with paths.
-
-All of them have the same interface, especially they can be built or extended
-using a standard Builder subclass. This make is easy to have e.g. the Dijkstra
-algorithm to store its result in any kind of path structure.
-
-\sa lemon::concept::Path
-
-*/
 
 ///\ingroup paths

lemon/radix_sort.h

@@ -20 +20 @@
 #define RADIX_SORT_H
 
-/// \ingroup auxdat
+/// \ingroup auxalg
 /// \file
 /// \brief Radix sort
@@ -195 +195 @@
   }
 
-  /// \ingroup auxdat
+  /// \ingroup auxalg
   ///
   /// \brief Sorts the stl compatible range into ascending order.
@@ -412 +412 @@
   }
 
-  /// \ingroup auxdat
+  /// \ingroup auxalg
   ///
   /// \brief Sorts stable the stl compatible range into ascending order.

lemon/ugraph_adaptor.h

@@ -39 +39 @@
 namespace lemon {
 
-  /// \ingroup graph_adaptors
-  ///
   /// \brief Base type for the Graph Adaptors
   ///
@@ -234 +232 @@
 
   /// \ingroup graph_adaptors
+  ///
+  /// \brief Trivial undirected graph adaptor
+  ///
+  /// This class is an adaptor which does not change the adapted undirected
+  /// graph. It can be used only to test the undirected graph adaptors.
   template <typename _UGraph>
   class UGraphAdaptor 
@@ -349 +352 @@
     }
 
-    ///\e
-
+    /// \brief Hide the given node in the graph.
+    ///
     /// This function hides \c n in the graph, i.e. the iteration 
     /// jumps over it. This is done by simply setting the value of \c n  
@@ -356 +359 @@
     void hide(const Node& n) const { node_filter_map->set(n, false); }
 
-    ///\e
-
+    /// \brief Hide the given undirected edge in the graph.
+    ///
     /// This function hides \c e in the graph, i.e. the iteration 
     /// jumps over it. This is done by simply setting the value of \c e  
-    /// to be false in the corresponding edge-map.
+    /// to be false in the corresponding uedge-map.
     void hide(const UEdge& e) const { uedge_filter_map->set(e, false); }
 
-    ///\e
-
+    /// \brief Unhide the given node in the graph.
+    ///
     /// The value of \c n is set to be true in the node-map which stores 
     /// hide information. If \c n was hidden previuosly, then it is shown 
@@ -370 +373 @@
      void unHide(const Node& n) const { node_filter_map->set(n, true); }
 
-    ///\e
-
-    /// The value of \c e is set to be true in the edge-map which stores 
+    /// \brief Hide the given undirected edge in the graph.
+    ///
+    /// The value of \c e is set to be true in the uedge-map which stores 
     /// hide information. If \c e was hidden previuosly, then it is shown 
     /// again
     void unHide(const UEdge& e) const { uedge_filter_map->set(e, true); }
 
+    /// \brief Returns true if \c n is hidden.
+    ///
     /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
     bool hidden(const Node& n) const { return !(*node_filter_map)[n]; }
 
-    /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
+    /// \brief Returns true if \c e is hidden.
+    ///
+    /// Returns true if \c e is hidden.
     bool hidden(const UEdge& e) const { return !(*uedge_filter_map)[e]; }
 
@@ -578 +579 @@
     }
 
-    ///\e
-
+    /// \brief Hide the given node in the graph.
+    ///
     /// This function hides \c n in the graph, i.e. the iteration 
     /// jumps over it. This is done by simply setting the value of \c n  
@@ -585 +586 @@
     void hide(const Node& n) const { node_filter_map->set(n, false); }
 
-    ///\e
-
+    /// \brief Hide the given undirected edge in the graph.
+    ///
     /// This function hides \c e in the graph, i.e. the iteration 
     /// jumps over it. This is done by simply setting the value of \c e  
-    /// to be false in the corresponding edge-map.
+    /// to be false in the corresponding uedge-map.
     void hide(const UEdge& e) const { uedge_filter_map->set(e, false); }
 
-    ///\e
-
+    /// \brief Unhide the given node in the graph.
+    ///
     /// The value of \c n is set to be true in the node-map which stores 
     /// hide information. If \c n was hidden previuosly, then it is shown 
@@ -599 +600 @@
      void unHide(const Node& n) const { node_filter_map->set(n, true); }
 
-    ///\e
-
-    /// The value of \c e is set to be true in the edge-map which stores 
+    /// \brief Hide the given undirected edge in the graph.
+    ///
+    /// The value of \c e is set to be true in the uedge-map which stores 
     /// hide information. If \c e was hidden previuosly, then it is shown 
     /// again
     void unHide(const UEdge& e) const { uedge_filter_map->set(e, true); }
 
+    /// \brief Returns true if \c n is hidden.
+    ///
     /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
     bool hidden(const Node& n) const { return !(*node_filter_map)[n]; }
 
-    /// Returns true if \c n is hidden.
-    
-    ///\e
-    ///
+    /// \brief Returns true if \c e is hidden.
+    ///
+    /// Returns true if \c e is hidden.
     bool hidden(const UEdge& e) const { return !(*uedge_filter_map)[e]; }
 
@@ -734 +733 @@
   /// node-filter.
   ///
-  /// Note that \c n is of type \c SubGA::NodeIt, but it can be converted to
-  /// \c Graph::Node that is why \c g.id(n) can be applied.
-  /// 
   template<typename _UGraph, typename NodeFilterMap, 
            typename UEdgeFilterMap, bool checked = true>