author Peter Kovacs Fri, 24 Jul 2009 10:27:40 +0200 changeset 760 4ac30454f1c1 parent 730 9f529abcaebf child 761 98a30824fe36
Small doc improvements
 doc/groups.dox file | annotate | diff | comparison | revisions lemon/bfs.h file | annotate | diff | comparison | revisions lemon/circulation.h file | annotate | diff | comparison | revisions lemon/dfs.h file | annotate | diff | comparison | revisions lemon/dijkstra.h file | annotate | diff | comparison | revisions lemon/gomory_hu.h file | annotate | diff | comparison | revisions lemon/min_cost_arborescence.h file | annotate | diff | comparison | revisions lemon/preflow.h file | annotate | diff | comparison | revisions
     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.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.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.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.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      ///@{