COIN-OR::LEMON - Graph Library

Changeset 762:ece80147fb08 in lemon


Ignore:
Timestamp:
09/25/09 09:06:32 (10 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Parents:
761:98a30824fe36 (diff), 759:6d5f547e5bfb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Phase:
public
Message:

Merge

Files:
6 edited

Legend:

Unmodified
Added
Removed
  • doc/groups.dox

    r757 r762  
    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}
  • doc/groups.dox

    r761 r762  
    239239any kind of path structure.
    240240
    241 \sa lemon::concepts::Path
     241\sa \ref concepts::Path "Path concept"
     242*/
     243
     244/**
     245@defgroup heaps Heap Structures
     246@ingroup datas
     247\brief %Heap structures implemented in LEMON.
     248
     249This group contains the heap structures implemented in LEMON.
     250
     251LEMON provides several heap classes. They are efficient implementations
     252of the abstract data type \e priority \e queue. They store items with
     253specified values called \e priorities in such a way that finding and
     254removing the item with minimum priority are efficient.
     255The basic operations are adding and erasing items, changing the priority
     256of an item, etc.
     257
     258Heaps are crucial in several algorithms, such as Dijkstra and Prim.
     259The heap implementations have the same interface, thus any of them can be
     260used easily in such algorithms.
     261
     262\sa \ref concepts::Heap "Heap concept"
     263*/
     264
     265/**
     266@defgroup matrices Matrices
     267@ingroup datas
     268\brief Two dimensional data storages implemented in LEMON.
     269
     270This group contains two dimensional data storages implemented in LEMON.
    242271*/
    243272
  • lemon/circulation.h

    r736 r762  
    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/circulation.h

    r760 r762  
    458458    }
    459459
    460     /// \brief Sets the tolerance used by algorithm.
    461     ///
    462     /// Sets the tolerance used by algorithm.
    463     Circulation& tolerance(const Tolerance& tolerance) const {
     460    /// \brief Sets the tolerance used by the algorithm.
     461    ///
     462    /// Sets the tolerance object used by the algorithm.
     463    /// \return <tt>(*this)</tt>
     464    Circulation& tolerance(const Tolerance& tolerance) {
    464465      _tol = tolerance;
    465466      return *this;
     
    468469    /// \brief Returns a const reference to the tolerance.
    469470    ///
    470     /// Returns a const reference to the tolerance.
     471    /// Returns a const reference to the tolerance object used by
     472    /// the algorithm.
    471473    const Tolerance& tolerance() const {
    472       return tolerance;
     474      return _tol;
    473475    }
    474476
  • lemon/preflow.h

    r736 r762  
    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
  • lemon/preflow.h

    r760 r762  
    105105  /// "flow of maximum value" in a digraph.
    106106  /// The preflow algorithms are the fastest known maximum
    107   /// flow algorithms. The current implementation use a mixture of the
     107  /// flow algorithms. The current implementation uses a mixture of the
    108108  /// \e "highest label" and the \e "bound decrease" heuristics.
    109109  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
     
    379379    }
    380380
    381     /// \brief Sets the tolerance used by algorithm.
    382     ///
    383     /// Sets the tolerance used by algorithm.
    384     Preflow& tolerance(const Tolerance& tolerance) const {
     381    /// \brief Sets the tolerance used by the algorithm.
     382    ///
     383    /// Sets the tolerance object used by the algorithm.
     384    /// \return <tt>(*this)</tt>
     385    Preflow& tolerance(const Tolerance& tolerance) {
    385386      _tolerance = tolerance;
    386387      return *this;
     
    389390    /// \brief Returns a const reference to the tolerance.
    390391    ///
    391     /// Returns a const reference to the tolerance.
     392    /// Returns a const reference to the tolerance object used by
     393    /// the algorithm.
    392394    const Tolerance& tolerance() const {
    393       return tolerance;
     395      return _tolerance;
    394396    }
    395397
Note: See TracChangeset for help on using the changeset viewer.