COIN-OR::LEMON - Graph Library

Changeset 760:4ac30454f1c1 in lemon


Ignore:
Timestamp:
07/24/09 10:27:40 (9 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Small doc improvements

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • doc/groups.dox

    r710 r760  
    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:
     
    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
  • lemon/bfs.h

    r525 r760  
    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.
     
    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.
  • lemon/circulation.h

    r688 r760  
    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.
     
    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.
     
    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
  • lemon/dfs.h

    r631 r760  
    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
     
    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
  • lemon/dijkstra.h

    r631 r760  
    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.
  • lemon/gomory_hu.h

    r643 r760  
    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
     
    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
  • lemon/min_cost_arborescence.h

    r672 r760  
    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
  • lemon/preflow.h

    r688 r760  
    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.
     
    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.
     
    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
Note: See TracChangeset for help on using the changeset viewer.