Small doc improvements
authorPeter Kovacs <kpeter@inf.elte.hu>
Fri, 24 Jul 2009 10:27:40 +0200
changeset 7604ac30454f1c1
parent 730 9f529abcaebf
child 761 98a30824fe36
Small doc improvements
doc/groups.dox
lemon/bfs.h
lemon/circulation.h
lemon/dfs.h
lemon/dijkstra.h
lemon/gomory_hu.h
lemon/min_cost_arborescence.h
lemon/preflow.h
     1.1 --- a/doc/groups.dox	Thu Jun 11 23:13:24 2009 +0200
     1.2 +++ b/doc/groups.dox	Fri Jul 24 10:27:40 2009 +0200
     1.3 @@ -375,7 +375,7 @@
     1.4  cut is the \f$X\f$ solution of the next optimization problem:
     1.5  
     1.6  \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
     1.7 -    \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
     1.8 +    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
     1.9  
    1.10  LEMON contains several algorithms related to minimum cut problems:
    1.11  
    1.12 @@ -398,8 +398,8 @@
    1.13  This group contains the algorithms for discovering the graph properties
    1.14  like connectivity, bipartiteness, euler property, simplicity etc.
    1.15  
    1.16 -\image html edge_biconnected_components.png
    1.17 -\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
    1.18 +\image html connected_components.png
    1.19 +\image latex connected_components.eps "Connected components" width=\textwidth
    1.20  */
    1.21  
    1.22  /**
     2.1 --- a/lemon/bfs.h	Thu Jun 11 23:13:24 2009 +0200
     2.2 +++ b/lemon/bfs.h	Fri Jul 24 10:27:40 2009 +0200
     2.3 @@ -413,8 +413,8 @@
     2.4      ///\name Execution Control
     2.5      ///The simplest way to execute the BFS algorithm is to use one of the
     2.6      ///member functions called \ref run(Node) "run()".\n
     2.7 -    ///If you need more control on the execution, first you have to call
     2.8 -    ///\ref init(), then you can add several source nodes with
     2.9 +    ///If you need better control on the execution, you have to call
    2.10 +    ///\ref init() first, then you can add several source nodes with
    2.11      ///\ref addSource(). Finally the actual path computation can be
    2.12      ///performed with one of the \ref start() functions.
    2.13  
    2.14 @@ -1425,8 +1425,8 @@
    2.15      /// \name Execution Control
    2.16      /// The simplest way to execute the BFS algorithm is to use one of the
    2.17      /// member functions called \ref run(Node) "run()".\n
    2.18 -    /// If you need more control on the execution, first you have to call
    2.19 -    /// \ref init(), then you can add several source nodes with
    2.20 +    /// If you need better control on the execution, you have to call
    2.21 +    /// \ref init() first, then you can add several source nodes with
    2.22      /// \ref addSource(). Finally the actual path computation can be
    2.23      /// performed with one of the \ref start() functions.
    2.24  
     3.1 --- a/lemon/circulation.h	Thu Jun 11 23:13:24 2009 +0200
     3.2 +++ b/lemon/circulation.h	Fri Jul 24 10:27:40 2009 +0200
     3.3 @@ -72,7 +72,11 @@
     3.4      /// The type of the map that stores the flow values.
     3.5      /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
     3.6      /// concept.
     3.7 +#ifdef DOXYGEN
     3.8 +    typedef GR::ArcMap<Value> FlowMap;
     3.9 +#else
    3.10      typedef typename Digraph::template ArcMap<Value> FlowMap;
    3.11 +#endif
    3.12  
    3.13      /// \brief Instantiates a FlowMap.
    3.14      ///
    3.15 @@ -87,9 +91,12 @@
    3.16      ///
    3.17      /// The elevator type used by the algorithm.
    3.18      ///
    3.19 -    /// \sa Elevator
    3.20 -    /// \sa LinkedElevator
    3.21 +    /// \sa Elevator, LinkedElevator
    3.22 +#ifdef DOXYGEN
    3.23 +    typedef lemon::Elevator<GR, GR::Node> Elevator;
    3.24 +#else
    3.25      typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
    3.26 +#endif
    3.27  
    3.28      /// \brief Instantiates an Elevator.
    3.29      ///
    3.30 @@ -467,8 +474,8 @@
    3.31  
    3.32      /// \name Execution Control
    3.33      /// The simplest way to execute the algorithm is to call \ref run().\n
    3.34 -    /// If you need more control on the initial solution or the execution,
    3.35 -    /// first you have to call one of the \ref init() functions, then
    3.36 +    /// If you need better control on the initial solution or the execution,
    3.37 +    /// you have to call one of the \ref init() functions first, then
    3.38      /// the \ref start() function.
    3.39  
    3.40      ///@{
     4.1 --- a/lemon/dfs.h	Thu Jun 11 23:13:24 2009 +0200
     4.2 +++ b/lemon/dfs.h	Fri Jul 24 10:27:40 2009 +0200
     4.3 @@ -411,8 +411,8 @@
     4.4      ///\name Execution Control
     4.5      ///The simplest way to execute the DFS algorithm is to use one of the
     4.6      ///member functions called \ref run(Node) "run()".\n
     4.7 -    ///If you need more control on the execution, first you have to call
     4.8 -    ///\ref init(), then you can add a source node with \ref addSource()
     4.9 +    ///If you need better control on the execution, you have to call
    4.10 +    ///\ref init() first, then you can add a source node with \ref addSource()
    4.11      ///and perform the actual computation with \ref start().
    4.12      ///This procedure can be repeated if there are nodes that have not
    4.13      ///been reached.
    4.14 @@ -1369,8 +1369,8 @@
    4.15      /// \name Execution Control
    4.16      /// The simplest way to execute the DFS algorithm is to use one of the
    4.17      /// member functions called \ref run(Node) "run()".\n
    4.18 -    /// If you need more control on the execution, first you have to call
    4.19 -    /// \ref init(), then you can add a source node with \ref addSource()
    4.20 +    /// If you need better control on the execution, you have to call
    4.21 +    /// \ref init() first, then you can add a source node with \ref addSource()
    4.22      /// and perform the actual computation with \ref start().
    4.23      /// This procedure can be repeated if there are nodes that have not
    4.24      /// been reached.
     5.1 --- a/lemon/dijkstra.h	Thu Jun 11 23:13:24 2009 +0200
     5.2 +++ b/lemon/dijkstra.h	Fri Jul 24 10:27:40 2009 +0200
     5.3 @@ -584,8 +584,8 @@
     5.4      ///\name Execution Control
     5.5      ///The simplest way to execute the %Dijkstra algorithm is to use
     5.6      ///one of the member functions called \ref run(Node) "run()".\n
     5.7 -    ///If you need more control on the execution, first you have to call
     5.8 -    ///\ref init(), then you can add several source nodes with
     5.9 +    ///If you need better control on the execution, you have to call
    5.10 +    ///\ref init() first, then you can add several source nodes with
    5.11      ///\ref addSource(). Finally the actual path computation can be
    5.12      ///performed with one of the \ref start() functions.
    5.13  
     6.1 --- a/lemon/gomory_hu.h	Thu Jun 11 23:13:24 2009 +0200
     6.2 +++ b/lemon/gomory_hu.h	Fri Jul 24 10:27:40 2009 +0200
     6.3 @@ -359,10 +359,10 @@
     6.4      /// This example counts the nodes in the minimum cut separating \c s from
     6.5      /// \c t.
     6.6      /// \code
     6.7 -    /// GomoruHu<Graph> gom(g, capacities);
     6.8 +    /// GomoryHu<Graph> gom(g, capacities);
     6.9      /// gom.run();
    6.10      /// int cnt=0;
    6.11 -    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
    6.12 +    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
    6.13      /// \endcode
    6.14      class MinCutNodeIt
    6.15      {
    6.16 @@ -456,10 +456,10 @@
    6.17      /// This example computes the value of the minimum cut separating \c s from
    6.18      /// \c t.
    6.19      /// \code
    6.20 -    /// GomoruHu<Graph> gom(g, capacities);
    6.21 +    /// GomoryHu<Graph> gom(g, capacities);
    6.22      /// gom.run();
    6.23      /// int value=0;
    6.24 -    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
    6.25 +    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
    6.26      ///   value+=capacities[e];
    6.27      /// \endcode
    6.28      /// The result will be the same as the value returned by
     7.1 --- a/lemon/min_cost_arborescence.h	Thu Jun 11 23:13:24 2009 +0200
     7.2 +++ b/lemon/min_cost_arborescence.h	Fri Jul 24 10:27:40 2009 +0200
     7.3 @@ -488,8 +488,8 @@
     7.4      /// \name Execution Control
     7.5      /// The simplest way to execute the algorithm is to use
     7.6      /// one of the member functions called \c run(...). \n
     7.7 -    /// If you need more control on the execution,
     7.8 -    /// first you must call \ref init(), then you can add several
     7.9 +    /// If you need better control on the execution,
    7.10 +    /// you have to call \ref init() first, then you can add several
    7.11      /// source nodes with \ref addSource().
    7.12      /// Finally \ref start() will perform the arborescence
    7.13      /// computation.
     8.1 --- a/lemon/preflow.h	Thu Jun 11 23:13:24 2009 +0200
     8.2 +++ b/lemon/preflow.h	Fri Jul 24 10:27:40 2009 +0200
     8.3 @@ -52,7 +52,11 @@
     8.4      ///
     8.5      /// The type of the map that stores the flow values.
     8.6      /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     8.7 +#ifdef DOXYGEN
     8.8 +    typedef GR::ArcMap<Value> FlowMap;
     8.9 +#else
    8.10      typedef typename Digraph::template ArcMap<Value> FlowMap;
    8.11 +#endif
    8.12  
    8.13      /// \brief Instantiates a FlowMap.
    8.14      ///
    8.15 @@ -67,9 +71,12 @@
    8.16      ///
    8.17      /// The elevator type used by Preflow algorithm.
    8.18      ///
    8.19 -    /// \sa Elevator
    8.20 -    /// \sa LinkedElevator
    8.21 -    typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
    8.22 +    /// \sa Elevator, LinkedElevator
    8.23 +#ifdef DOXYGEN
    8.24 +    typedef lemon::Elevator<GR, GR::Node> Elevator;
    8.25 +#else
    8.26 +    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
    8.27 +#endif
    8.28  
    8.29      /// \brief Instantiates an Elevator.
    8.30      ///
    8.31 @@ -389,8 +396,8 @@
    8.32      /// \name Execution Control
    8.33      /// The simplest way to execute the preflow algorithm is to use
    8.34      /// \ref run() or \ref runMinCut().\n
    8.35 -    /// If you need more control on the initial solution or the execution,
    8.36 -    /// first you have to call one of the \ref init() functions, then
    8.37 +    /// If you need better control on the initial solution or the execution,
    8.38 +    /// you have to call one of the \ref init() functions first, then
    8.39      /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
    8.40  
    8.41      ///@{