# Changeset 715:ece80147fb08 in lemon-1.2

Ignore:
Timestamp:
09/25/09 09:06:32 (12 years ago)
Branch:
default
Parents:
714:98a30824fe36 (diff), 712: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

Unmodified
Removed
• ## doc/groups.dox

 r710 /** @defgroup geomdat Geometric Data Structures @ingroup auxdat \brief Geometric data structures implemented in LEMON. This group contains geometric data structures implemented in LEMON. - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional vector with the usual operations. - \ref lemon::dim2::Box "dim2::Box" can be used to determine the rectangular bounding box of a set of \ref lemon::dim2::Point "dim2::Point"'s. */ /** @defgroup matrices Matrices @ingroup auxdat \brief Two dimensional data storages implemented in LEMON. This group contains two dimensional data storages implemented in LEMON. */ /** @defgroup algs Algorithms \brief This group contains the several algorithms /** @defgroup spantree Minimum Spanning Tree Algorithms @ingroup algs \brief Algorithms for finding minimum cost spanning trees and arborescences. This group contains the algorithms for finding minimum cost spanning trees and arborescences. */ /** @defgroup max_flow Maximum Flow Algorithms @ingroup algs \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f] \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] LEMON contains several algorithms related to minimum cut problems: If you want to find minimum cut just between two distinict nodes, see the \ref max_flow "maximum flow problem". */ /** @defgroup graph_properties Connectivity and Other Graph Properties @ingroup algs \brief Algorithms for discovering the graph properties This group contains the algorithms for discovering the graph properties like connectivity, bipartiteness, euler property, simplicity etc. \image html edge_biconnected_components.png \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth */ /** @defgroup planar Planarity Embedding and Drawing @ingroup algs \brief Algorithms for planarity checking, embedding and drawing This group contains the algorithms for planarity checking, embedding and drawing. \image html planar.png \image latex planar.eps "Plane graph" width=\textwidth */ /** @defgroup spantree Minimum Spanning Tree Algorithms @ingroup algs \brief Algorithms for finding minimum cost spanning trees and arborescences. This group contains the algorithms for finding minimum cost spanning trees and arborescences. @defgroup graph_properties Connectivity and Other Graph Properties @ingroup algs \brief Algorithms for discovering the graph properties This group contains the algorithms for discovering the graph properties like connectivity, bipartiteness, euler property, simplicity etc. \image html connected_components.png \image latex connected_components.eps "Connected components" width=\textwidth */ /** @defgroup planar Planarity Embedding and Drawing @ingroup algs \brief Algorithms for planarity checking, embedding and drawing This group contains the algorithms for planarity checking, embedding and drawing. \image html planar.png \image latex planar.eps "Plane graph" width=\textwidth */ /** @defgroup approx Approximation Algorithms @ingroup algs \brief Approximation algorithms. This group contains the approximation and heuristic algorithms implemented in LEMON. */ This group contains some algorithms implemented in LEMON in order to make it easier to implement complex algorithms. */ /** @defgroup approx Approximation Algorithms @ingroup algs \brief Approximation algorithms. This group contains the approximation and heuristic algorithms implemented in LEMON. */ /** @defgroup dimacs_group DIMACS format @defgroup dimacs_group DIMACS Format @ingroup io_group \brief Read and write files in DIMACS format /** @defgroup tools Standalone Utility Applications Some utility applications are listed here. The standard compilation procedure (./configure;make) will compile them, as well. */ /** \anchor demoprograms */ /** @defgroup tools Standalone Utility Applications Some utility applications are listed here. The standard compilation procedure (./configure;make) will compile them, as well. */ }
• ## doc/groups.dox

 r714 any kind of path structure. \sa lemon::concepts::Path \sa \ref concepts::Path "Path concept" */ /** @defgroup heaps Heap Structures @ingroup datas \brief %Heap structures implemented in LEMON. This group contains the heap structures implemented in LEMON. LEMON provides several heap classes. They are efficient implementations of the abstract data type \e priority \e queue. They store items with specified values called \e priorities in such a way that finding and removing the item with minimum priority are efficient. The basic operations are adding and erasing items, changing the priority of an item, etc. Heaps are crucial in several algorithms, such as Dijkstra and Prim. The heap implementations have the same interface, thus any of them can be used easily in such algorithms. \sa \ref concepts::Heap "Heap concept" */ /** @defgroup matrices Matrices @ingroup datas \brief Two dimensional data storages implemented in LEMON. This group contains two dimensional data storages implemented in LEMON. */
• ## lemon/circulation.h

 r689 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept. #ifdef DOXYGEN typedef GR::ArcMap FlowMap; #else typedef typename Digraph::template ArcMap FlowMap; #endif /// \brief Instantiates a FlowMap. /// The elevator type used by the algorithm. /// /// \sa Elevator /// \sa LinkedElevator /// \sa Elevator, LinkedElevator #ifdef DOXYGEN typedef lemon::Elevator Elevator; #else typedef lemon::Elevator Elevator; #endif /// \brief Instantiates an Elevator. /// \name Execution Control /// The simplest way to execute the algorithm is to call \ref run().\n /// If you need more control on the initial solution or the execution, /// first you have to call one of the \ref init() functions, then /// If you need better control on the initial solution or the execution, /// you have to call one of the \ref init() functions first, then /// the \ref start() function.
• ## lemon/circulation.h

 r713 } /// \brief Sets the tolerance used by algorithm. /// /// Sets the tolerance used by algorithm. Circulation& tolerance(const Tolerance& tolerance) const { /// \brief Sets the tolerance used by the algorithm. /// /// Sets the tolerance object used by the algorithm. /// \return (*this) Circulation& tolerance(const Tolerance& tolerance) { _tol = tolerance; return *this; /// \brief Returns a const reference to the tolerance. /// /// Returns a const reference to the tolerance. /// Returns a const reference to the tolerance object used by /// the algorithm. const Tolerance& tolerance() const { return tolerance; return _tol; }
• ## lemon/preflow.h

 r689 /// The type of the map that stores the flow values. /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. #ifdef DOXYGEN typedef GR::ArcMap FlowMap; #else typedef typename Digraph::template ArcMap FlowMap; #endif /// \brief Instantiates a FlowMap. /// The elevator type used by Preflow algorithm. /// /// \sa Elevator /// \sa LinkedElevator typedef LinkedElevator Elevator; /// \sa Elevator, LinkedElevator #ifdef DOXYGEN typedef lemon::Elevator Elevator; #else typedef lemon::Elevator Elevator; #endif /// \brief Instantiates an Elevator. /// The simplest way to execute the preflow algorithm is to use /// \ref run() or \ref runMinCut().\n /// If you need more control on the initial solution or the execution, /// first you have to call one of the \ref init() functions, then /// If you need better control on the initial solution or the execution, /// you have to call one of the \ref init() functions first, then /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
• ## lemon/preflow.h

 r713 /// "flow of maximum value" in a digraph. /// The preflow algorithms are the fastest known maximum /// flow algorithms. The current implementation use a mixture of the /// flow algorithms. The current implementation uses a mixture of the /// \e "highest label" and the \e "bound decrease" heuristics. /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. } /// \brief Sets the tolerance used by algorithm. /// /// Sets the tolerance used by algorithm. Preflow& tolerance(const Tolerance& tolerance) const { /// \brief Sets the tolerance used by the algorithm. /// /// Sets the tolerance object used by the algorithm. /// \return (*this) Preflow& tolerance(const Tolerance& tolerance) { _tolerance = tolerance; return *this; /// \brief Returns a const reference to the tolerance. /// /// Returns a const reference to the tolerance. /// Returns a const reference to the tolerance object used by /// the algorithm. const Tolerance& tolerance() const { return tolerance; return _tolerance; }
Note: See TracChangeset for help on using the changeset viewer.