COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #303: 303-doc-impr-4ac30454f1c1.patch

File 303-doc-impr-4ac30454f1c1.patch, 8.7 KB (added by Peter Kovacs, 15 years ago)

  • doc/groups.dox 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1248424060 -7200
# Node ID 4ac30454f1c13ba27b62fec6b649a2a6a944480e
# Parent  9f529abcaebf13f19e61ba24fdd2c3631860af91
Small doc improvements

diff --git a/doc/groups.dox b/doc/groups.dox
    a b  
    375375cut is the \f$X\f$ solution of the next optimization problem:
    376376
    377377\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
    378     \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
     378    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
    379379
    380380LEMON contains several algorithms related to minimum cut problems:
    381381
    … …  
    398398This group contains the algorithms for discovering the graph properties
    399399like connectivity, bipartiteness, euler property, simplicity etc.
    400400
    401 \image html edge_biconnected_components.png
    402 \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
     401\image html connected_components.png
     402\image latex connected_components.eps "Connected components" width=\textwidth
    403403*/
    404404
    405405/**

  • lemon/bfs.h 

    diff --git a/lemon/bfs.h b/lemon/bfs.h
    a b  
    413413    ///\name Execution Control
    414414    ///The simplest way to execute the BFS algorithm is to use one of the
    415415    ///member functions called \ref run(Node) "run()".\n
    416     ///If you need more control on the execution, first you have to call
    417     ///\ref init(), then you can add several source nodes with
     416    ///If you need better control on the execution, you have to call
     417    ///\ref init() first, then you can add several source nodes with
    418418    ///\ref addSource(). Finally the actual path computation can be
    419419    ///performed with one of the \ref start() functions.
    420420
    … …  
    14251425    /// \name Execution Control
    14261426    /// The simplest way to execute the BFS algorithm is to use one of the
    14271427    /// member functions called \ref run(Node) "run()".\n
    1428     /// If you need more control on the execution, first you have to call
    1429     /// \ref init(), then you can add several source nodes with
     1428    /// If you need better control on the execution, you have to call
     1429    /// \ref init() first, then you can add several source nodes with
    14301430    /// \ref addSource(). Finally the actual path computation can be
    14311431    /// performed with one of the \ref start() functions.
    14321432

  • lemon/circulation.h 

    diff --git a/lemon/circulation.h b/lemon/circulation.h
    a b  
    7272    /// The type of the map that stores the flow values.
    7373    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
    7474    /// concept.
     75#ifdef DOXYGEN
     76    typedef GR::ArcMap<Value> FlowMap;
     77#else
    7578    typedef typename Digraph::template ArcMap<Value> FlowMap;
     79#endif
    7680
    7781    /// \brief Instantiates a FlowMap.
    7882    ///
    … …  
    8791    ///
    8892    /// The elevator type used by the algorithm.
    8993    ///
    90     /// \sa Elevator
    91     /// \sa LinkedElevator
     94    /// \sa Elevator, LinkedElevator
     95#ifdef DOXYGEN
     96    typedef lemon::Elevator<GR, GR::Node> Elevator;
     97#else
    9298    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
     99#endif
    93100
    94101    /// \brief Instantiates an Elevator.
    95102    ///
    … …  
    467474
    468475    /// \name Execution Control
    469476    /// The simplest way to execute the algorithm is to call \ref run().\n
    470     /// If you need more control on the initial solution or the execution,
    471     /// first you have to call one of the \ref init() functions, then
     477    /// If you need better control on the initial solution or the execution,
     478    /// you have to call one of the \ref init() functions first, then
    472479    /// the \ref start() function.
    473480
    474481    ///@{

  • lemon/dfs.h 

    diff --git a/lemon/dfs.h b/lemon/dfs.h
    a b  
    411411    ///\name Execution Control
    412412    ///The simplest way to execute the DFS algorithm is to use one of the
    413413    ///member functions called \ref run(Node) "run()".\n
    414     ///If you need more control on the execution, first you have to call
    415     ///\ref init(), then you can add a source node with \ref addSource()
     414    ///If you need better control on the execution, you have to call
     415    ///\ref init() first, then you can add a source node with \ref addSource()
    416416    ///and perform the actual computation with \ref start().
    417417    ///This procedure can be repeated if there are nodes that have not
    418418    ///been reached.
    … …  
    13691369    /// \name Execution Control
    13701370    /// The simplest way to execute the DFS algorithm is to use one of the
    13711371    /// member functions called \ref run(Node) "run()".\n
    1372     /// If you need more control on the execution, first you have to call
    1373     /// \ref init(), then you can add a source node with \ref addSource()
     1372    /// If you need better control on the execution, you have to call
     1373    /// \ref init() first, then you can add a source node with \ref addSource()
    13741374    /// and perform the actual computation with \ref start().
    13751375    /// This procedure can be repeated if there are nodes that have not
    13761376    /// been reached.

  • lemon/dijkstra.h 

    diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h
    a b  
    584584    ///\name Execution Control
    585585    ///The simplest way to execute the %Dijkstra algorithm is to use
    586586    ///one of the member functions called \ref run(Node) "run()".\n
    587     ///If you need more control on the execution, first you have to call
    588     ///\ref init(), then you can add several source nodes with
     587    ///If you need better control on the execution, you have to call
     588    ///\ref init() first, then you can add several source nodes with
    589589    ///\ref addSource(). Finally the actual path computation can be
    590590    ///performed with one of the \ref start() functions.
    591591

  • lemon/gomory_hu.h 

    diff --git a/lemon/gomory_hu.h b/lemon/gomory_hu.h
    a b  
    359359    /// This example counts the nodes in the minimum cut separating \c s from
    360360    /// \c t.
    361361    /// \code
    362     /// GomoruHu<Graph> gom(g, capacities);
     362    /// GomoryHu<Graph> gom(g, capacities);
    363363    /// gom.run();
    364364    /// int cnt=0;
    365     /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
     365    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
    366366    /// \endcode
    367367    class MinCutNodeIt
    368368    {
    … …  
    456456    /// This example computes the value of the minimum cut separating \c s from
    457457    /// \c t.
    458458    /// \code
    459     /// GomoruHu<Graph> gom(g, capacities);
     459    /// GomoryHu<Graph> gom(g, capacities);
    460460    /// gom.run();
    461461    /// int value=0;
    462     /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
     462    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
    463463    ///   value+=capacities[e];
    464464    /// \endcode
    465465    /// The result will be the same as the value returned by

  • lemon/min_cost_arborescence.h 

    diff --git a/lemon/min_cost_arborescence.h b/lemon/min_cost_arborescence.h
    a b  
    488488    /// \name Execution Control
    489489    /// The simplest way to execute the algorithm is to use
    490490    /// one of the member functions called \c run(...). \n
    491     /// If you need more control on the execution,
    492     /// first you must call \ref init(), then you can add several
     491    /// If you need better control on the execution,
     492    /// you have to call \ref init() first, then you can add several
    493493    /// source nodes with \ref addSource().
    494494    /// Finally \ref start() will perform the arborescence
    495495    /// computation.

  • lemon/preflow.h 

    diff --git a/lemon/preflow.h b/lemon/preflow.h
    a b  
    5252    ///
    5353    /// The type of the map that stores the flow values.
    5454    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     55#ifdef DOXYGEN
     56    typedef GR::ArcMap<Value> FlowMap;
     57#else
    5558    typedef typename Digraph::template ArcMap<Value> FlowMap;
     59#endif
    5660
    5761    /// \brief Instantiates a FlowMap.
    5862    ///
    … …  
    6771    ///
    6872    /// The elevator type used by Preflow algorithm.
    6973    ///
    70     /// \sa Elevator
    71     /// \sa LinkedElevator
    72     typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
     74    /// \sa Elevator, LinkedElevator
     75#ifdef DOXYGEN
     76    typedef lemon::Elevator<GR, GR::Node> Elevator;
     77#else
     78    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
     79#endif
    7380
    7481    /// \brief Instantiates an Elevator.
    7582    ///
    … …  
    389396    /// \name Execution Control
    390397    /// The simplest way to execute the preflow algorithm is to use
    391398    /// \ref run() or \ref runMinCut().\n
    392     /// If you need more control on the initial solution or the execution,
    393     /// first you have to call one of the \ref init() functions, then
     399    /// If you need better control on the initial solution or the execution,
     400    /// you have to call one of the \ref init() functions first, then
    394401    /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
    395402
    396403    ///@{