COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search


Ignore:
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • doc/groups.dox

    r762 r757  
    281281
    282282/**
    283 @defgroup geomdat Geometric Data Structures
    284 @ingroup auxdat
    285 \brief Geometric data structures implemented in LEMON.
    286 
    287 This group contains geometric data structures implemented in LEMON.
    288 
    289  - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional
    290    vector with the usual operations.
    291  - \ref lemon::dim2::Box "dim2::Box" can be used to determine the
    292    rectangular bounding box of a set of \ref lemon::dim2::Point
    293    "dim2::Point"'s.
    294 */
    295 
    296 /**
    297 @defgroup matrices Matrices
    298 @ingroup auxdat
    299 \brief Two dimensional data storages implemented in LEMON.
    300 
    301 This group contains two dimensional data storages implemented in LEMON.
    302 */
    303 
    304 /**
    305283@defgroup algs Algorithms
    306284\brief This group contains the several algorithms
    … …  
    342320
    343321/**
    344 @defgroup spantree Minimum Spanning Tree Algorithms
    345 @ingroup algs
    346 \brief Algorithms for finding minimum cost spanning trees and arborescences.
    347 
    348 This group contains the algorithms for finding minimum cost spanning
    349 trees and arborescences.
    350 */
    351 
    352 /**
    353322@defgroup max_flow Maximum Flow Algorithms
    354323@ingroup algs
    … …  
    428397
    429398\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
    430     \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
     399    \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
    431400
    432401LEMON contains several algorithms related to minimum cut problems:
    … …  
    441410If you want to find minimum cut just between two distinict nodes,
    442411see the \ref max_flow "maximum flow problem".
     412*/
     413
     414/**
     415@defgroup graph_properties Connectivity and Other Graph Properties
     416@ingroup algs
     417\brief Algorithms for discovering the graph properties
     418
     419This group contains the algorithms for discovering the graph properties
     420like connectivity, bipartiteness, euler property, simplicity etc.
     421
     422\image html edge_biconnected_components.png
     423\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
     424*/
     425
     426/**
     427@defgroup planar Planarity Embedding and Drawing
     428@ingroup algs
     429\brief Algorithms for planarity checking, embedding and drawing
     430
     431This group contains the algorithms for planarity checking,
     432embedding and drawing.
     433
     434\image html planar.png
     435\image latex planar.eps "Plane graph" width=\textwidth
    443436*/
    444437
    … …  
    484477
    485478/**
    486 @defgroup graph_properties Connectivity and Other Graph Properties
    487 @ingroup algs
    488 \brief Algorithms for discovering the graph properties
    489 
    490 This group contains the algorithms for discovering the graph properties
    491 like connectivity, bipartiteness, euler property, simplicity etc.
    492 
    493 \image html connected_components.png
    494 \image latex connected_components.eps "Connected components" width=\textwidth
    495 */
    496 
    497 /**
    498 @defgroup planar Planarity Embedding and Drawing
    499 @ingroup algs
    500 \brief Algorithms for planarity checking, embedding and drawing
    501 
    502 This group contains the algorithms for planarity checking,
    503 embedding and drawing.
    504 
    505 \image html planar.png
    506 \image latex planar.eps "Plane graph" width=\textwidth
     479@defgroup spantree Minimum Spanning Tree Algorithms
     480@ingroup algs
     481\brief Algorithms for finding minimum cost spanning trees and arborescences.
     482
     483This group contains the algorithms for finding minimum cost spanning
     484trees and arborescences.
     485*/
     486
     487/**
     488@defgroup auxalg Auxiliary Algorithms
     489@ingroup algs
     490\brief Auxiliary algorithms implemented in LEMON.
     491
     492This group contains some algorithms implemented in LEMON
     493in order to make it easier to implement complex algorithms.
    507494*/
    508495
    … …  
    514501This group contains the approximation and heuristic algorithms
    515502implemented in LEMON.
    516 */
    517 
    518 /**
    519 @defgroup auxalg Auxiliary Algorithms
    520 @ingroup algs
    521 \brief Auxiliary algorithms implemented in LEMON.
    522 
    523 This group contains some algorithms implemented in LEMON
    524 in order to make it easier to implement complex algorithms.
    525503*/
    526504
    … …  
    631609
    632610/**
    633 @defgroup dimacs_group DIMACS Format
     611@defgroup dimacs_group DIMACS format
    634612@ingroup io_group
    635613\brief Read and write files in DIMACS format
    … …  
    693671
    694672/**
     673\anchor demoprograms
     674
     675@defgroup demos Demo Programs
     676
     677Some demo programs are listed here. Their full source codes can be found in
     678the \c demo subdirectory of the source tree.
     679
     680In order to compile them, use the <tt>make demo</tt> or the
     681<tt>make check</tt> commands.
     682*/
     683
     684/**
    695685@defgroup tools Standalone Utility Applications
    696686
    … …  
    701691*/
    702692
    703 /**
    704 \anchor demoprograms
    705 
    706 @defgroup demos Demo Programs
    707 
    708 Some demo programs are listed here. Their full source codes can be found in
    709 the \c demo subdirectory of the source tree.
    710 
    711 In order to compile them, use the <tt>make demo</tt> or the
    712 <tt>make check</tt> commands.
    713 */
    714 
    715693}

  • lemon/bfs.h

    r760 r525  
    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 better control on the execution, you have to call
    417     ///\ref init() first, then you can add several source nodes with
     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
    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 better control on the execution, you have to call
    1429     /// \ref init() first, then you can add several source nodes with
     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
    14301430    /// \ref addSource(). Finally the actual path computation can be
    14311431    /// performed with one of the \ref start() functions.

  • lemon/circulation.h

    r762 r736  
    7373    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
    7474    /// concept.
    75 #ifdef DOXYGEN
    76     typedef GR::ArcMap<Value> FlowMap;
    77 #else
    7875    typedef typename Digraph::template ArcMap<Value> FlowMap;
    79 #endif
    8076
    8177    /// \brief Instantiates a FlowMap.
    … …  
    9288    /// The elevator type used by the algorithm.
    9389    ///
    94     /// \sa Elevator, LinkedElevator
    95 #ifdef DOXYGEN
    96     typedef lemon::Elevator<GR, GR::Node> Elevator;
    97 #else
     90    /// \sa Elevator
     91    /// \sa LinkedElevator
    9892    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
    99 #endif
    10093
    10194    /// \brief Instantiates an Elevator.
    … …  
    477470    /// \name Execution Control
    478471    /// The simplest way to execute the algorithm is to call \ref run().\n
    479     /// If you need better control on the initial solution or the execution,
    480     /// you have to call one of the \ref init() functions first, then
     472    /// If you need more control on the initial solution or the execution,
     473    /// first you have to call one of the \ref init() functions, then
    481474    /// the \ref start() function.
    482475

  • lemon/dfs.h

    r760 r631  
    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 better control on the execution, you have to call
    415     ///\ref init() first, then you can add a source node with \ref addSource()
     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()
    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 better control on the execution, you have to call
    1373     /// \ref init() first, then you can add a source node with \ref addSource()
     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()
    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

    r760 r631  
    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 better control on the execution, you have to call
    588     ///\ref init() first, then you can add several source nodes with
     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
    589589    ///\ref addSource(). Finally the actual path computation can be
    590590    ///performed with one of the \ref start() functions.

  • lemon/dim2.h

    r761 r463  
    2222#include <iostream>
    2323
    24 ///\ingroup geomdat
     24///\ingroup misc
    2525///\file
    2626///\brief A simple two dimensional vector and a bounding box implementation
     27///
     28/// The class \ref lemon::dim2::Point "dim2::Point" implements
     29/// a two dimensional vector with the usual operations.
     30///
     31/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
     32/// the rectangular bounding box of a set of
     33/// \ref lemon::dim2::Point "dim2::Point"'s.
    2734
    2835namespace lemon {
    … …  
    3441  namespace dim2 {
    3542
    36   /// \addtogroup geomdat
     43  /// \addtogroup misc
    3744  /// @{
    3845

  • lemon/gomory_hu.h

    r760 r643  
    360360    /// \c t.
    361361    /// \code
    362     /// GomoryHu<Graph> gom(g, capacities);
     362    /// GomoruHu<Graph> gom(g, capacities);
    363363    /// gom.run();
    364364    /// int cnt=0;
    365     /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
     365    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
    366366    /// \endcode
    367367    class MinCutNodeIt
    … …  
    457457    /// \c t.
    458458    /// \code
    459     /// GomoryHu<Graph> gom(g, capacities);
     459    /// GomoruHu<Graph> gom(g, capacities);
    460460    /// gom.run();
    461461    /// int value=0;
    462     /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
     462    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
    463463    ///   value+=capacities[e];
    464464    /// \endcode

  • lemon/min_cost_arborescence.h

    r760 r672  
    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 better control on the execution,
    492     /// you have to call \ref init() first, then you can add several
     491    /// If you need more control on the execution,
     492    /// first you must call \ref init(), then you can add several
    493493    /// source nodes with \ref addSource().
    494494    /// Finally \ref start() will perform the arborescence

  • lemon/preflow.h

    r762 r736  
    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
    5855    typedef typename Digraph::template ArcMap<Value> FlowMap;
    59 #endif
    6056
    6157    /// \brief Instantiates a FlowMap.
    … …  
    7268    /// The elevator type used by Preflow algorithm.
    7369    ///
    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
     70    /// \sa Elevator
     71    /// \sa LinkedElevator
     72    typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
    8073
    8174    /// \brief Instantiates an Elevator.
    … …  
    399392    /// The simplest way to execute the preflow algorithm is to use
    400393    /// \ref run() or \ref runMinCut().\n
    401     /// If you need better control on the initial solution or the execution,
    402     /// you have to call one of the \ref init() functions first, then
     394    /// If you need more control on the initial solution or the execution,
     395    /// first you have to call one of the \ref init() functions, then
    403396    /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
    404397
Note: See TracChangeset for help on using the changeset viewer.