COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [712:6d5f547e5bfb:715:ece80147fb08] in lemon-1.2


Ignore:
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • doc/groups.dox

    r710 r715  
    281281
    282282/**
     283@defgroup geomdat Geometric Data Structures
     284@ingroup auxdat
     285\brief Geometric data structures implemented in LEMON.
     286
     287This 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
     301This group contains two dimensional data storages implemented in LEMON.
     302*/
     303
     304/**
    283305@defgroup algs Algorithms
    284306\brief This group contains the several algorithms
    … …  
    320342
    321343/**
     344@defgroup spantree Minimum Spanning Tree Algorithms
     345@ingroup algs
     346\brief Algorithms for finding minimum cost spanning trees and arborescences.
     347
     348This group contains the algorithms for finding minimum cost spanning
     349trees and arborescences.
     350*/
     351
     352/**
    322353@defgroup max_flow Maximum Flow Algorithms
    323354@ingroup algs
    … …  
    397428
    398429\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
    399     \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
     430    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
    400431
    401432LEMON contains several algorithms related to minimum cut problems:
    … …  
    410441If you want to find minimum cut just between two distinict nodes,
    411442see 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 
    419 This group contains the algorithms for discovering the graph properties
    420 like 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 
    431 This group contains the algorithms for planarity checking,
    432 embedding and drawing.
    433 
    434 \image html planar.png
    435 \image latex planar.eps "Plane graph" width=\textwidth
    436443*/
    437444
    … …  
    477484
    478485/**
    479 @defgroup spantree Minimum Spanning Tree Algorithms
    480 @ingroup algs
    481 \brief Algorithms for finding minimum cost spanning trees and arborescences.
    482 
    483 This group contains the algorithms for finding minimum cost spanning
    484 trees and arborescences.
     486@defgroup graph_properties Connectivity and Other Graph Properties
     487@ingroup algs
     488\brief Algorithms for discovering the graph properties
     489
     490This group contains the algorithms for discovering the graph properties
     491like 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
     502This group contains the algorithms for planarity checking,
     503embedding and drawing.
     504
     505\image html planar.png
     506\image latex planar.eps "Plane graph" width=\textwidth
     507*/
     508
     509/**
     510@defgroup approx Approximation Algorithms
     511@ingroup algs
     512\brief Approximation algorithms.
     513
     514This group contains the approximation and heuristic algorithms
     515implemented in LEMON.
    485516*/
    486517
    … …  
    492523This group contains some algorithms implemented in LEMON
    493524in order to make it easier to implement complex algorithms.
    494 */
    495 
    496 /**
    497 @defgroup approx Approximation Algorithms
    498 @ingroup algs
    499 \brief Approximation algorithms.
    500 
    501 This group contains the approximation and heuristic algorithms
    502 implemented in LEMON.
    503525*/
    504526
    … …  
    609631
    610632/**
    611 @defgroup dimacs_group DIMACS format
     633@defgroup dimacs_group DIMACS Format
    612634@ingroup io_group
    613635\brief Read and write files in DIMACS format
    … …  
    671693
    672694/**
     695@defgroup tools Standalone Utility Applications
     696
     697Some utility applications are listed here.
     698
     699The standard compilation procedure (<tt>./configure;make</tt>) will compile
     700them, as well.
     701*/
     702
     703/**
    673704\anchor demoprograms
    674705
    … …  
    682713*/
    683714
    684 /**
    685 @defgroup tools Standalone Utility Applications
    686 
    687 Some utility applications are listed here.
    688 
    689 The standard compilation procedure (<tt>./configure;make</tt>) will compile
    690 them, as well.
    691 */
    692 
    693715}

  • lemon/bfs.h

    r492 r713  
    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

    r689 r715  
    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.
    … …  
    470477    /// \name Execution Control
    471478    /// The simplest way to execute the algorithm is to call \ref run().\n
    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
     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
    474481    /// the \ref start() function.
    475482

  • lemon/dfs.h

    r584 r713  
    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

    r584 r713  
    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/dim2.h

    r440 r714  
    2222#include <iostream>
    2323
    24 ///\ingroup misc
     24///\ingroup geomdat
    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.
    3427
    3528namespace lemon {
    … …  
    4134  namespace dim2 {
    4235
    43   /// \addtogroup misc
     36  /// \addtogroup geomdat
    4437  /// @{
    4538

  • lemon/gomory_hu.h

    r596 r713  
    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

    r625 r713  
    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

    r689 r715  
    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.
    … …  
    392399    /// The simplest way to execute the preflow algorithm is to use
    393400    /// \ref run() or \ref runMinCut().\n
    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
     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
    396403    /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
    397404
Note: See TracChangeset for help on using the changeset viewer.