COIN-OR::LEMON - Graph Library

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

File 303-doc-impr-4ac30454f1c1.patch, 8.7 KB (added by Peter Kovacs, 10 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    ///@{