Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt (revision 744)
+++ CMakeLists.txt (revision 680)
@@ -35,6 +35,4 @@
CHECK_TYPE_SIZE("long long" LONG_LONG)
SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
-
-INCLUDE(FindPythonInterp)
ENABLE_TESTING()
Index: configure.ac
===================================================================
--- configure.ac (revision 744)
+++ configure.ac (revision 680)
@@ -42,5 +42,4 @@
AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
-AC_CHECK_PROG([python_found],[python],[yes],[no])
AC_CHECK_PROG([gs_found],[gs],[yes],[no])
Index: doc/CMakeLists.txt
===================================================================
--- doc/CMakeLists.txt (revision 744)
+++ doc/CMakeLists.txt (revision 679)
@@ -10,5 +10,5 @@
)
-IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
+IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha)
@@ -29,5 +29,4 @@
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
COMMAND ${CMAKE_COMMAND} -E remove_directory html
- COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
Index: doc/Doxyfile.in
===================================================================
--- doc/Doxyfile.in (revision 744)
+++ doc/Doxyfile.in (revision 367)
@@ -92,6 +92,5 @@
"@abs_top_srcdir@/demo" \
"@abs_top_srcdir@/tools" \
- "@abs_top_srcdir@/test/test_tools.h" \
- "@abs_top_builddir@/doc/references.dox"
+ "@abs_top_srcdir@/test/test_tools.h"
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.h \
Index: doc/Makefile.am
===================================================================
--- doc/Makefile.am (revision 744)
+++ doc/Makefile.am (revision 673)
@@ -67,17 +67,5 @@
fi
-references.dox: doc/references.bib
- if test ${python_found} = yes; then \
- cd doc; \
- python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \
- cd ..; \
- else \
- echo; \
- echo "Python not found."; \
- echo; \
- exit 1; \
- fi
-
-html-local: $(DOC_PNG_IMAGES) references.dox
+html-local: $(DOC_PNG_IMAGES)
if test ${doxygen_found} = yes; then \
cd doc; \
Index: doc/groups.dox
===================================================================
--- doc/groups.dox (revision 742)
+++ doc/groups.dox (revision 663)
@@ -227,4 +227,12 @@
/**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group contains two dimensional data storages implemented in LEMON.
+*/
+
+/**
@defgroup paths Path Structures
@ingroup datas
@@ -239,34 +247,5 @@
any kind of path structure.
-\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.
+\sa lemon::concepts::Path
*/
@@ -278,26 +257,4 @@
This group contains some data structures implemented in LEMON in
order to make it easier to implement combinatorial algorithms.
-*/
-
-/**
-@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.
*/
@@ -342,13 +299,4 @@
/**
-@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
@@ -428,5 +376,5 @@
\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:
@@ -441,4 +389,28 @@
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
*/
@@ -484,25 +456,19 @@
/**
-@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 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 auxalg Auxiliary Algorithms
+@ingroup algs
+\brief Auxiliary algorithms implemented in LEMON.
+
+This group contains some algorithms implemented in LEMON
+in order to make it easier to implement complex algorithms.
*/
@@ -514,13 +480,4 @@
This group contains the approximation and heuristic algorithms
implemented in LEMON.
-*/
-
-/**
-@defgroup auxalg Auxiliary Algorithms
-@ingroup algs
-\brief Auxiliary algorithms implemented in LEMON.
-
-This group contains some algorithms implemented in LEMON
-in order to make it easier to implement complex algorithms.
*/
@@ -631,5 +588,5 @@
/**
-@defgroup dimacs_group DIMACS Format
+@defgroup dimacs_group DIMACS format
@ingroup io_group
\brief Read and write files in DIMACS format
@@ -680,6 +637,6 @@
\brief Skeleton and concept checking classes for graph structures
-This group contains the skeletons and concept checking classes of
-graph structures.
+This group contains the skeletons and concept checking classes of LEMON's
+graph structures and helper classes used to implement these.
*/
@@ -693,4 +650,16 @@
/**
+\anchor demoprograms
+
+@defgroup demos Demo Programs
+
+Some demo programs are listed here. Their full source codes can be found in
+the \c demo subdirectory of the source tree.
+
+In order to compile them, use the make demo or the
+make check commands.
+*/
+
+/**
@defgroup tools Standalone Utility Applications
@@ -701,15 +670,3 @@
*/
-/**
-\anchor demoprograms
-
-@defgroup demos Demo Programs
-
-Some demo programs are listed here. Their full source codes can be found in
-the \c demo subdirectory of the source tree.
-
-In order to compile them, use the make demo or the
-make check commands.
-*/
-
}
Index: c/references.bib
===================================================================
--- doc/references.bib (revision 743)
+++ (revision )
@@ -1,341 +1,0 @@
-%%%%% Defining LEMON %%%%%
-
-@misc{lemon,
- key = {LEMON},
- title = {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and
- {O}ptimization in {N}etworks},
- howpublished = {\url{http://lemon.cs.elte.hu/}},
- year = 2009
-}
-
-@misc{egres,
- key = {EGRES},
- title = {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on
- {C}ombinatorial {O}ptimization},
- howpublished = {\url{http://www.cs.elte.hu/egres/}},
- year = 2009
-}
-
-@misc{coinor,
- key = {COIN-OR},
- title = {{COIN-OR} -- {C}omputational {I}nfrastructure for
- {O}perations {R}esearch},
- howpublished = {\url{http://www.coin-or.org/}},
- year = 2009
-}
-
-
-%%%%% Other libraries %%%%%%
-
-@misc{boost,
- key = {Boost},
- title = {{B}oost {C++} {L}ibraries},
- howpublished = {\url{http://www.boost.org/}},
- year = 2009
-}
-
-@book{bglbook,
- author = {Jeremy G. Siek and Lee-Quan Lee and Andrew
- Lumsdaine},
- title = {The Boost Graph Library: User Guide and Reference
- Manual},
- publisher = {Addison-Wesley},
- year = 2002
-}
-
-@misc{leda,
- key = {LEDA},
- title = {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and
- {A}lgorithms},
- howpublished = {\url{http://www.algorithmic-solutions.com/}},
- year = 2009
-}
-
-@book{ledabook,
- author = {Kurt Mehlhorn and Stefan N{\"a}her},
- title = {{LEDA}: {A} platform for combinatorial and geometric
- computing},
- isbn = {0-521-56329-1},
- publisher = {Cambridge University Press},
- address = {New York, NY, USA},
- year = 1999
-}
-
-
-%%%%% Tools that LEMON depends on %%%%%
-
-@misc{cmake,
- key = {CMake},
- title = {{CMake} -- {C}ross {P}latform {M}ake},
- howpublished = {\url{http://www.cmake.org/}},
- year = 2009
-}
-
-@misc{doxygen,
- key = {Doxygen},
- title = {{Doxygen} -- {S}ource code documentation generator
- tool},
- howpublished = {\url{http://www.doxygen.org/}},
- year = 2009
-}
-
-
-%%%%% LP/MIP libraries %%%%%
-
-@misc{glpk,
- key = {GLPK},
- title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it},
- howpublished = {\url{http://www.gnu.org/software/glpk/}},
- year = 2009
-}
-
-@misc{clp,
- key = {Clp},
- title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming},
- howpublished = {\url{http://projects.coin-or.org/Clp/}},
- year = 2009
-}
-
-@misc{cbc,
- key = {Cbc},
- title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut},
- howpublished = {\url{http://projects.coin-or.org/Cbc/}},
- year = 2009
-}
-
-@misc{cplex,
- key = {CPLEX},
- title = {{ILOG} {CPLEX}},
- howpublished = {\url{http://www.ilog.com/}},
- year = 2009
-}
-
-@misc{soplex,
- key = {SoPlex},
- title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented
- {S}implex},
- howpublished = {\url{http://soplex.zib.de/}},
- year = 2009
-}
-
-
-%%%%% General books %%%%%
-
-@book{amo93networkflows,
- author = {Ravindra K. Ahuja and Thomas L. Magnanti and James
- B. Orlin},
- title = {Network Flows: Theory, Algorithms, and Applications},
- publisher = {Prentice-Hall, Inc.},
- year = 1993,
- month = feb,
- isbn = {978-0136175490}
-}
-
-@book{schrijver03combinatorial,
- author = {Alexander Schrijver},
- title = {Combinatorial Optimization: Polyhedra and Efficiency},
- publisher = {Springer-Verlag},
- year = 2003,
- isbn = {978-3540443896}
-}
-
-@book{clrs01algorithms,
- author = {Thomas H. Cormen and Charles E. Leiserson and Ronald
- L. Rivest and Clifford Stein},
- title = {Introduction to Algorithms},
- publisher = {The MIT Press},
- year = 2001,
- edition = {2nd}
-}
-
-@book{stroustrup00cpp,
- author = {Bjarne Stroustrup},
- title = {The C++ Programming Language},
- edition = {3rd},
- publisher = {Addison-Wesley Professional},
- isbn = 0201700735,
- month = {February},
- year = 2000
-}
-
-
-%%%%% Maximum flow algorithms %%%%%
-
-@inproceedings{goldberg86newapproach,
- author = {Andrew V. Goldberg and Robert E. Tarjan},
- title = {A new approach to the maximum flow problem},
- booktitle = {STOC '86: Proceedings of the Eighteenth Annual ACM
- Symposium on Theory of Computing},
- year = 1986,
- publisher = {ACM Press},
- address = {New York, NY},
- pages = {136-146}
-}
-
-@article{dinic70algorithm,
- author = {E. A. Dinic},
- title = {Algorithm for solution of a problem of maximum flow
- in a network with power estimation},
- journal = {Soviet Math. Doklady},
- year = 1970,
- volume = 11,
- pages = {1277-1280}
-}
-
-@article{goldberg08partial,
- author = {Andrew V. Goldberg},
- title = {The Partial Augment-Relabel Algorithm for the
- Maximum Flow Problem},
- journal = {16th Annual European Symposium on Algorithms},
- year = 2008,
- pages = {466-477}
-}
-
-@article{sleator83dynamic,
- author = {Daniel D. Sleator and Robert E. Tarjan},
- title = {A data structure for dynamic trees},
- journal = {Journal of Computer and System Sciences},
- year = 1983,
- volume = 26,
- number = 3,
- pages = {362-391}
-}
-
-
-%%%%% Minimum mean cycle algorithms %%%%%
-
-@article{karp78characterization,
- author = {Richard M. Karp},
- title = {A characterization of the minimum cycle mean in a
- digraph},
- journal = {Discrete Math.},
- year = 1978,
- volume = 23,
- pages = {309-311}
-}
-
-@article{dasdan98minmeancycle,
- author = {Ali Dasdan and Rajesh K. Gupta},
- title = {Faster Maximum and Minimum Mean Cycle Alogrithms for
- System Performance Analysis},
- journal = {IEEE Transactions on Computer-Aided Design of
- Integrated Circuits and Systems},
- year = 1998,
- volume = 17,
- number = 10,
- pages = {889-899}
-}
-
-
-%%%%% Minimum cost flow algorithms %%%%%
-
-@article{klein67primal,
- author = {Morton Klein},
- title = {A primal method for minimal cost flows with
- applications to the assignment and transportation
- problems},
- journal = {Management Science},
- year = 1967,
- volume = 14,
- pages = {205-220}
-}
-
-@inproceedings{goldberg88cyclecanceling,
- author = {Andrew V. Goldberg and Robert E. Tarjan},
- title = {Finding minimum-cost circulations by canceling
- negative cycles},
- booktitle = {STOC '88: Proceedings of the Twentieth Annual ACM
- Symposium on Theory of Computing},
- year = 1988,
- publisher = {ACM Press},
- address = {New York, NY},
- pages = {388-397}
-}
-
-@article{edmondskarp72theoretical,
- author = {Jack Edmonds and Richard M. Karp},
- title = {Theoretical improvements in algorithmic efficiency
- for network flow problems},
- journal = {Journal of the ACM},
- year = 1972,
- volume = 19,
- number = 2,
- pages = {248-264}
-}
-
-@inproceedings{goldberg87approximation,
- author = {Andrew V. Goldberg and Robert E. Tarjan},
- title = {Solving minimum-cost flow problems by successive
- approximation},
- booktitle = {STOC '87: Proceedings of the Nineteenth Annual ACM
- Symposium on Theory of Computing},
- year = 1987,
- publisher = {ACM Press},
- address = {New York, NY},
- pages = {7-18}
-}
-
-@article{goldberg90finding,
- author = {Andrew V. Goldberg and Robert E. Tarjan},
- title = {Finding Minimum-Cost Circulations by Successive
- Approximation},
- journal = {Mathematics of Operations Research},
- year = 1990,
- volume = 15,
- number = 3,
- pages = {430-466}
-}
-
-@article{goldberg97efficient,
- author = {Andrew V. Goldberg},
- title = {An Efficient Implementation of a Scaling
- Minimum-Cost Flow Algorithm},
- journal = {Journal of Algorithms},
- year = 1997,
- volume = 22,
- number = 1,
- pages = {1-29}
-}
-
-@article{bunnagel98efficient,
- author = {Ursula B{\"u}nnagel and Bernhard Korte and Jens
- Vygen},
- title = {Efficient implementation of the {G}oldberg-{T}arjan
- minimum-cost flow algorithm},
- journal = {Optimization Methods and Software},
- year = 1998,
- volume = 10,
- pages = {157-174}
-}
-
-@mastersthesis{kellyoneill91netsimplex,
- author = {Damian J. Kelly and Garrett M. O'Neill},
- title = {The Minimum Cost Flow Problem and The Network
- Simplex Method},
- school = {University College},
- address = {Dublin, Ireland},
- year = 1991,
- month = sep,
-}
-
-@techreport{lobel96networksimplex,
- author = {Andreas L{\"o}bel},
- title = {Solving large-scale real-world minimum-cost flow
- problems by a network simplex method},
- institution = {Konrad-Zuse-Zentrum fur Informationstechnik Berlin
- ({ZIB})},
- address = {Berlin, Germany},
- year = 1996,
- number = {SC 96-7}
-}
-
-@article{frangioni06computational,
- author = {Antonio Frangioni and Antonio Manca},
- title = {A Computational Study of Cost Reoptimization for
- Min-Cost Flow Problems},
- journal = {INFORMS Journal On Computing},
- year = 2006,
- volume = 18,
- number = 1,
- pages = {61-70}
-}
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am (revision 708)
+++ lemon/Makefile.am (revision 667)
@@ -58,9 +58,6 @@
lemon/arg_parser.h \
lemon/assert.h \
- lemon/bellman_ford.h \
lemon/bfs.h \
lemon/bin_heap.h \
- lemon/binom_heap.h \
- lemon/bucket_heap.h \
lemon/cbc.h \
lemon/circulation.h \
@@ -80,6 +77,4 @@
lemon/error.h \
lemon/euler.h \
- lemon/fib_heap.h \
- lemon/fourary_heap.h \
lemon/full_graph.h \
lemon/glpk.h \
@@ -88,5 +83,4 @@
lemon/grid_graph.h \
lemon/hypercube_graph.h \
- lemon/kary_heap.h \
lemon/kruskal.h \
lemon/hao_orlin.h \
@@ -97,4 +91,5 @@
lemon/lp_base.h \
lemon/lp_skeleton.h \
+ lemon/list_graph.h \
lemon/maps.h \
lemon/matching.h \
@@ -103,8 +98,6 @@
lemon/nauty_reader.h \
lemon/network_simplex.h \
- lemon/pairing_heap.h \
lemon/path.h \
lemon/preflow.h \
- lemon/radix_heap.h \
lemon/radix_sort.h \
lemon/random.h \
Index: mon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h (revision 699)
+++ (revision )
@@ -1,1100 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BELLMAN_FORD_H
-#define LEMON_BELLMAN_FORD_H
-
-/// \ingroup shortest_path
-/// \file
-/// \brief Bellman-Ford algorithm.
-
-#include
-#include
-#include
-#include
-#include
-
-#include
-
-namespace lemon {
-
- /// \brief Default OperationTraits for the BellmanFord algorithm class.
- ///
- /// This operation traits class defines all computational operations
- /// and constants that are used in the Bellman-Ford algorithm.
- /// The default implementation is based on the \c numeric_limits class.
- /// If the numeric type does not have infinity value, then the maximum
- /// value is used as extremal infinity value.
- template <
- typename V,
- bool has_inf = std::numeric_limits::has_infinity>
- struct BellmanFordDefaultOperationTraits {
- /// \e
- typedef V Value;
- /// \brief Gives back the zero value of the type.
- static Value zero() {
- return static_cast(0);
- }
- /// \brief Gives back the positive infinity value of the type.
- static Value infinity() {
- return std::numeric_limits::infinity();
- }
- /// \brief Gives back the sum of the given two elements.
- static Value plus(const Value& left, const Value& right) {
- return left + right;
- }
- /// \brief Gives back \c true only if the first value is less than
- /// the second.
- static bool less(const Value& left, const Value& right) {
- return left < right;
- }
- };
-
- template
- struct BellmanFordDefaultOperationTraits {
- typedef V Value;
- static Value zero() {
- return static_cast(0);
- }
- static Value infinity() {
- return std::numeric_limits::max();
- }
- static Value plus(const Value& left, const Value& right) {
- if (left == infinity() || right == infinity()) return infinity();
- return left + right;
- }
- static bool less(const Value& left, const Value& right) {
- return left < right;
- }
- };
-
- /// \brief Default traits class of BellmanFord class.
- ///
- /// Default traits class of BellmanFord class.
- /// \param GR The type of the digraph.
- /// \param LEN The type of the length map.
- template
- struct BellmanFordDefaultTraits {
- /// The type of the digraph the algorithm runs on.
- typedef GR Digraph;
-
- /// \brief The type of the map that stores the arc lengths.
- ///
- /// The type of the map that stores the arc lengths.
- /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
- typedef LEN LengthMap;
-
- /// The type of the arc lengths.
- typedef typename LEN::Value Value;
-
- /// \brief Operation traits for Bellman-Ford algorithm.
- ///
- /// It defines the used operations and the infinity value for the
- /// given \c Value type.
- /// \see BellmanFordDefaultOperationTraits
- typedef BellmanFordDefaultOperationTraits OperationTraits;
-
- /// \brief The type of the map that stores the last arcs of the
- /// shortest paths.
- ///
- /// The type of the map that stores the last
- /// arcs of the shortest paths.
- /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- typedef typename GR::template NodeMap PredMap;
-
- /// \brief Instantiates a \c PredMap.
- ///
- /// This function instantiates a \ref PredMap.
- /// \param g is the digraph to which we would like to define the
- /// \ref PredMap.
- static PredMap *createPredMap(const GR& g) {
- return new PredMap(g);
- }
-
- /// \brief The type of the map that stores the distances of the nodes.
- ///
- /// The type of the map that stores the distances of the nodes.
- /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- typedef typename GR::template NodeMap DistMap;
-
- /// \brief Instantiates a \c DistMap.
- ///
- /// This function instantiates a \ref DistMap.
- /// \param g is the digraph to which we would like to define the
- /// \ref DistMap.
- static DistMap *createDistMap(const GR& g) {
- return new DistMap(g);
- }
-
- };
-
- /// \brief %BellmanFord algorithm class.
- ///
- /// \ingroup shortest_path
- /// This class provides an efficient implementation of the Bellman-Ford
- /// algorithm. The maximum time complexity of the algorithm is
- /// O(ne).
- ///
- /// The Bellman-Ford algorithm solves the single-source shortest path
- /// problem when the arcs can have negative lengths, but the digraph
- /// should not contain directed cycles with negative total length.
- /// If all arc costs are non-negative, consider to use the Dijkstra
- /// algorithm instead, since it is more efficient.
- ///
- /// The arc lengths are passed to the algorithm using a
- /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
- /// kind of length. The type of the length values is determined by the
- /// \ref concepts::ReadMap::Value "Value" type of the length map.
- ///
- /// There is also a \ref bellmanFord() "function-type interface" for the
- /// Bellman-Ford algorithm, which is convenient in the simplier cases and
- /// it can be used easier.
- ///
- /// \tparam GR The type of the digraph the algorithm runs on.
- /// The default type is \ref ListDigraph.
- /// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies
- /// the lengths of the arcs. The default map type is
- /// \ref concepts::Digraph::ArcMap "GR::ArcMap".
-#ifdef DOXYGEN
- template
-#else
- template ,
- typename TR=BellmanFordDefaultTraits >
-#endif
- class BellmanFord {
- public:
-
- ///The type of the underlying digraph.
- typedef typename TR::Digraph Digraph;
-
- /// \brief The type of the arc lengths.
- typedef typename TR::LengthMap::Value Value;
- /// \brief The type of the map that stores the arc lengths.
- typedef typename TR::LengthMap LengthMap;
- /// \brief The type of the map that stores the last
- /// arcs of the shortest paths.
- typedef typename TR::PredMap PredMap;
- /// \brief The type of the map that stores the distances of the nodes.
- typedef typename TR::DistMap DistMap;
- /// The type of the paths.
- typedef PredMapPath Path;
- ///\brief The \ref BellmanFordDefaultOperationTraits
- /// "operation traits class" of the algorithm.
- typedef typename TR::OperationTraits OperationTraits;
-
- ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm.
- typedef TR Traits;
-
- private:
-
- typedef typename Digraph::Node Node;
- typedef typename Digraph::NodeIt NodeIt;
- typedef typename Digraph::Arc Arc;
- typedef typename Digraph::OutArcIt OutArcIt;
-
- // Pointer to the underlying digraph.
- const Digraph *_gr;
- // Pointer to the length map
- const LengthMap *_length;
- // Pointer to the map of predecessors arcs.
- PredMap *_pred;
- // Indicates if _pred is locally allocated (true) or not.
- bool _local_pred;
- // Pointer to the map of distances.
- DistMap *_dist;
- // Indicates if _dist is locally allocated (true) or not.
- bool _local_dist;
-
- typedef typename Digraph::template NodeMap MaskMap;
- MaskMap *_mask;
-
- std::vector _process;
-
- // Creates the maps if necessary.
- void create_maps() {
- if(!_pred) {
- _local_pred = true;
- _pred = Traits::createPredMap(*_gr);
- }
- if(!_dist) {
- _local_dist = true;
- _dist = Traits::createDistMap(*_gr);
- }
- _mask = new MaskMap(*_gr, false);
- }
-
- public :
-
- typedef BellmanFord Create;
-
- /// \name Named Template Parameters
-
- ///@{
-
- template
- struct SetPredMapTraits : public Traits {
- typedef T PredMap;
- static PredMap *createPredMap(const Digraph&) {
- LEMON_ASSERT(false, "PredMap is not initialized");
- return 0; // ignore warnings
- }
- };
-
- /// \brief \ref named-templ-param "Named parameter" for setting
- /// \c PredMap type.
- ///
- /// \ref named-templ-param "Named parameter" for setting
- /// \c PredMap type.
- /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- template
- struct SetPredMap
- : public BellmanFord< Digraph, LengthMap, SetPredMapTraits > {
- typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits > Create;
- };
-
- template
- struct SetDistMapTraits : public Traits {
- typedef T DistMap;
- static DistMap *createDistMap(const Digraph&) {
- LEMON_ASSERT(false, "DistMap is not initialized");
- return 0; // ignore warnings
- }
- };
-
- /// \brief \ref named-templ-param "Named parameter" for setting
- /// \c DistMap type.
- ///
- /// \ref named-templ-param "Named parameter" for setting
- /// \c DistMap type.
- /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- template
- struct SetDistMap
- : public BellmanFord< Digraph, LengthMap, SetDistMapTraits > {
- typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits > Create;
- };
-
- template
- struct SetOperationTraitsTraits : public Traits {
- typedef T OperationTraits;
- };
-
- /// \brief \ref named-templ-param "Named parameter" for setting
- /// \c OperationTraits type.
- ///
- /// \ref named-templ-param "Named parameter" for setting
- /// \c OperationTraits type.
- /// For more information see \ref BellmanFordDefaultOperationTraits.
- template
- struct SetOperationTraits
- : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits > {
- typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits >
- Create;
- };
-
- ///@}
-
- protected:
-
- BellmanFord() {}
-
- public:
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param g The digraph the algorithm runs on.
- /// \param length The length map used by the algorithm.
- BellmanFord(const Digraph& g, const LengthMap& length) :
- _gr(&g), _length(&length),
- _pred(0), _local_pred(false),
- _dist(0), _local_dist(false), _mask(0) {}
-
- ///Destructor.
- ~BellmanFord() {
- if(_local_pred) delete _pred;
- if(_local_dist) delete _dist;
- if(_mask) delete _mask;
- }
-
- /// \brief Sets the length map.
- ///
- /// Sets the length map.
- /// \return (*this)
- BellmanFord &lengthMap(const LengthMap &map) {
- _length = ↦
- return *this;
- }
-
- /// \brief Sets the map that stores the predecessor arcs.
- ///
- /// Sets the map that stores the predecessor arcs.
- /// If you don't use this function before calling \ref run()
- /// or \ref init(), an instance will be allocated automatically.
- /// The destructor deallocates this automatically allocated map,
- /// of course.
- /// \return (*this)
- BellmanFord &predMap(PredMap &map) {
- if(_local_pred) {
- delete _pred;
- _local_pred=false;
- }
- _pred = ↦
- return *this;
- }
-
- /// \brief Sets the map that stores the distances of the nodes.
- ///
- /// Sets the map that stores the distances of the nodes calculated
- /// by the algorithm.
- /// If you don't use this function before calling \ref run()
- /// or \ref init(), an instance will be allocated automatically.
- /// The destructor deallocates this automatically allocated map,
- /// of course.
- /// \return (*this)
- BellmanFord &distMap(DistMap &map) {
- if(_local_dist) {
- delete _dist;
- _local_dist=false;
- }
- _dist = ↦
- return *this;
- }
-
- /// \name Execution Control
- /// The simplest way to execute the Bellman-Ford algorithm is to use
- /// one of the member functions called \ref run().\n
- /// If you need better control on the execution, you have to call
- /// \ref init() first, then you can add several source nodes
- /// with \ref addSource(). Finally the actual path computation can be
- /// performed with \ref start(), \ref checkedStart() or
- /// \ref limitedStart().
-
- ///@{
-
- /// \brief Initializes the internal data structures.
- ///
- /// Initializes the internal data structures. The optional parameter
- /// is the initial distance of each node.
- void init(const Value value = OperationTraits::infinity()) {
- create_maps();
- for (NodeIt it(*_gr); it != INVALID; ++it) {
- _pred->set(it, INVALID);
- _dist->set(it, value);
- }
- _process.clear();
- if (OperationTraits::less(value, OperationTraits::infinity())) {
- for (NodeIt it(*_gr); it != INVALID; ++it) {
- _process.push_back(it);
- _mask->set(it, true);
- }
- }
- }
-
- /// \brief Adds a new source node.
- ///
- /// This function adds a new source node. The optional second parameter
- /// is the initial distance of the node.
- void addSource(Node source, Value dst = OperationTraits::zero()) {
- _dist->set(source, dst);
- if (!(*_mask)[source]) {
- _process.push_back(source);
- _mask->set(source, true);
- }
- }
-
- /// \brief Executes one round from the Bellman-Ford algorithm.
- ///
- /// If the algoritm calculated the distances in the previous round
- /// exactly for the paths of at most \c k arcs, then this function
- /// will calculate the distances exactly for the paths of at most
- /// k+1 arcs. Performing \c k iterations using this function
- /// calculates the shortest path distances exactly for the paths
- /// consisting of at most \c k arcs.
- ///
- /// \warning The paths with limited arc number cannot be retrieved
- /// easily with \ref path() or \ref predArc() functions. If you also
- /// need the shortest paths and not only the distances, you should
- /// store the \ref predMap() "predecessor map" after each iteration
- /// and build the path manually.
- ///
- /// \return \c true when the algorithm have not found more shorter
- /// paths.
- ///
- /// \see ActiveIt
- bool processNextRound() {
- for (int i = 0; i < int(_process.size()); ++i) {
- _mask->set(_process[i], false);
- }
- std::vector nextProcess;
- std::vector values(_process.size());
- for (int i = 0; i < int(_process.size()); ++i) {
- values[i] = (*_dist)[_process[i]];
- }
- for (int i = 0; i < int(_process.size()); ++i) {
- for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
- Node target = _gr->target(it);
- Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
- if (OperationTraits::less(relaxed, (*_dist)[target])) {
- _pred->set(target, it);
- _dist->set(target, relaxed);
- if (!(*_mask)[target]) {
- _mask->set(target, true);
- nextProcess.push_back(target);
- }
- }
- }
- }
- _process.swap(nextProcess);
- return _process.empty();
- }
-
- /// \brief Executes one weak round from the Bellman-Ford algorithm.
- ///
- /// If the algorithm calculated the distances in the previous round
- /// at least for the paths of at most \c k arcs, then this function
- /// will calculate the distances at least for the paths of at most
- /// k+1 arcs.
- /// This function does not make it possible to calculate the shortest
- /// path distances exactly for paths consisting of at most \c k arcs,
- /// this is why it is called weak round.
- ///
- /// \return \c true when the algorithm have not found more shorter
- /// paths.
- ///
- /// \see ActiveIt
- bool processNextWeakRound() {
- for (int i = 0; i < int(_process.size()); ++i) {
- _mask->set(_process[i], false);
- }
- std::vector nextProcess;
- for (int i = 0; i < int(_process.size()); ++i) {
- for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
- Node target = _gr->target(it);
- Value relaxed =
- OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
- if (OperationTraits::less(relaxed, (*_dist)[target])) {
- _pred->set(target, it);
- _dist->set(target, relaxed);
- if (!(*_mask)[target]) {
- _mask->set(target, true);
- nextProcess.push_back(target);
- }
- }
- }
- }
- _process.swap(nextProcess);
- return _process.empty();
- }
-
- /// \brief Executes the algorithm.
- ///
- /// Executes the algorithm.
- ///
- /// This method runs the Bellman-Ford algorithm from the root node(s)
- /// in order to compute the shortest path to each node.
- ///
- /// The algorithm computes
- /// - the shortest path tree (forest),
- /// - the distance of each node from the root(s).
- ///
- /// \pre init() must be called and at least one root node should be
- /// added with addSource() before using this function.
- void start() {
- int num = countNodes(*_gr) - 1;
- for (int i = 0; i < num; ++i) {
- if (processNextWeakRound()) break;
- }
- }
-
- /// \brief Executes the algorithm and checks the negative cycles.
- ///
- /// Executes the algorithm and checks the negative cycles.
- ///
- /// This method runs the Bellman-Ford algorithm from the root node(s)
- /// in order to compute the shortest path to each node and also checks
- /// if the digraph contains cycles with negative total length.
- ///
- /// The algorithm computes
- /// - the shortest path tree (forest),
- /// - the distance of each node from the root(s).
- ///
- /// \return \c false if there is a negative cycle in the digraph.
- ///
- /// \pre init() must be called and at least one root node should be
- /// added with addSource() before using this function.
- bool checkedStart() {
- int num = countNodes(*_gr);
- for (int i = 0; i < num; ++i) {
- if (processNextWeakRound()) return true;
- }
- return _process.empty();
- }
-
- /// \brief Executes the algorithm with arc number limit.
- ///
- /// Executes the algorithm with arc number limit.
- ///
- /// This method runs the Bellman-Ford algorithm from the root node(s)
- /// in order to compute the shortest path distance for each node
- /// using only the paths consisting of at most \c num arcs.
- ///
- /// The algorithm computes
- /// - the limited distance of each node from the root(s),
- /// - the predecessor arc for each node.
- ///
- /// \warning The paths with limited arc number cannot be retrieved
- /// easily with \ref path() or \ref predArc() functions. If you also
- /// need the shortest paths and not only the distances, you should
- /// store the \ref predMap() "predecessor map" after each iteration
- /// and build the path manually.
- ///
- /// \pre init() must be called and at least one root node should be
- /// added with addSource() before using this function.
- void limitedStart(int num) {
- for (int i = 0; i < num; ++i) {
- if (processNextRound()) break;
- }
- }
-
- /// \brief Runs the algorithm from the given root node.
- ///
- /// This method runs the Bellman-Ford algorithm from the given root
- /// node \c s in order to compute the shortest path to each node.
- ///
- /// The algorithm computes
- /// - the shortest path tree (forest),
- /// - the distance of each node from the root(s).
- ///
- /// \note bf.run(s) is just a shortcut of the following code.
- /// \code
- /// bf.init();
- /// bf.addSource(s);
- /// bf.start();
- /// \endcode
- void run(Node s) {
- init();
- addSource(s);
- start();
- }
-
- /// \brief Runs the algorithm from the given root node with arc
- /// number limit.
- ///
- /// This method runs the Bellman-Ford algorithm from the given root
- /// node \c s in order to compute the shortest path distance for each
- /// node using only the paths consisting of at most \c num arcs.
- ///
- /// The algorithm computes
- /// - the limited distance of each node from the root(s),
- /// - the predecessor arc for each node.
- ///
- /// \warning The paths with limited arc number cannot be retrieved
- /// easily with \ref path() or \ref predArc() functions. If you also
- /// need the shortest paths and not only the distances, you should
- /// store the \ref predMap() "predecessor map" after each iteration
- /// and build the path manually.
- ///
- /// \note bf.run(s, num) is just a shortcut of the following code.
- /// \code
- /// bf.init();
- /// bf.addSource(s);
- /// bf.limitedStart(num);
- /// \endcode
- void run(Node s, int num) {
- init();
- addSource(s);
- limitedStart(num);
- }
-
- ///@}
-
- /// \brief LEMON iterator for getting the active nodes.
- ///
- /// This class provides a common style LEMON iterator that traverses
- /// the active nodes of the Bellman-Ford algorithm after the last
- /// phase. These nodes should be checked in the next phase to
- /// find augmenting arcs outgoing from them.
- class ActiveIt {
- public:
-
- /// \brief Constructor.
- ///
- /// Constructor for getting the active nodes of the given BellmanFord
- /// instance.
- ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
- {
- _index = _algorithm->_process.size() - 1;
- }
-
- /// \brief Invalid constructor.
- ///
- /// Invalid constructor.
- ActiveIt(Invalid) : _algorithm(0), _index(-1) {}
-
- /// \brief Conversion to \c Node.
- ///
- /// Conversion to \c Node.
- operator Node() const {
- return _index >= 0 ? _algorithm->_process[_index] : INVALID;
- }
-
- /// \brief Increment operator.
- ///
- /// Increment operator.
- ActiveIt& operator++() {
- --_index;
- return *this;
- }
-
- bool operator==(const ActiveIt& it) const {
- return static_cast(*this) == static_cast(it);
- }
- bool operator!=(const ActiveIt& it) const {
- return static_cast(*this) != static_cast(it);
- }
- bool operator<(const ActiveIt& it) const {
- return static_cast(*this) < static_cast(it);
- }
-
- private:
- const BellmanFord* _algorithm;
- int _index;
- };
-
- /// \name Query Functions
- /// The result of the Bellman-Ford algorithm can be obtained using these
- /// functions.\n
- /// Either \ref run() or \ref init() should be called before using them.
-
- ///@{
-
- /// \brief The shortest path to the given node.
- ///
- /// Gives back the shortest path to the given node from the root(s).
- ///
- /// \warning \c t should be reached from the root(s).
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- Path path(Node t) const
- {
- return Path(*_gr, *_pred, t);
- }
-
- /// \brief The distance of the given node from the root(s).
- ///
- /// Returns the distance of the given node from the root(s).
- ///
- /// \warning If node \c v is not reached from the root(s), then
- /// the return value of this function is undefined.
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- Value dist(Node v) const { return (*_dist)[v]; }
-
- /// \brief Returns the 'previous arc' of the shortest path tree for
- /// the given node.
- ///
- /// This function returns the 'previous arc' of the shortest path
- /// tree for node \c v, i.e. it returns the last arc of a
- /// shortest path from a root to \c v. It is \c INVALID if \c v
- /// is not reached from the root(s) or if \c v is a root.
- ///
- /// The shortest path tree used here is equal to the shortest path
- /// tree used in \ref predNode() and \predMap().
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- Arc predArc(Node v) const { return (*_pred)[v]; }
-
- /// \brief Returns the 'previous node' of the shortest path tree for
- /// the given node.
- ///
- /// This function returns the 'previous node' of the shortest path
- /// tree for node \c v, i.e. it returns the last but one node of
- /// a shortest path from a root to \c v. It is \c INVALID if \c v
- /// is not reached from the root(s) or if \c v is a root.
- ///
- /// The shortest path tree used here is equal to the shortest path
- /// tree used in \ref predArc() and \predMap().
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- Node predNode(Node v) const {
- return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
- }
-
- /// \brief Returns a const reference to the node map that stores the
- /// distances of the nodes.
- ///
- /// Returns a const reference to the node map that stores the distances
- /// of the nodes calculated by the algorithm.
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- const DistMap &distMap() const { return *_dist;}
-
- /// \brief Returns a const reference to the node map that stores the
- /// predecessor arcs.
- ///
- /// Returns a const reference to the node map that stores the predecessor
- /// arcs, which form the shortest path tree (forest).
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- const PredMap &predMap() const { return *_pred; }
-
- /// \brief Checks if a node is reached from the root(s).
- ///
- /// Returns \c true if \c v is reached from the root(s).
- ///
- /// \pre Either \ref run() or \ref init() must be called before
- /// using this function.
- bool reached(Node v) const {
- return (*_dist)[v] != OperationTraits::infinity();
- }
-
- /// \brief Gives back a negative cycle.
- ///
- /// This function gives back a directed cycle with negative total
- /// length if the algorithm has already found one.
- /// Otherwise it gives back an empty path.
- lemon::Path negativeCycle() {
- typename Digraph::template NodeMap state(*_gr, -1);
- lemon::Path cycle;
- for (int i = 0; i < int(_process.size()); ++i) {
- if (state[_process[i]] != -1) continue;
- for (Node v = _process[i]; (*_pred)[v] != INVALID;
- v = _gr->source((*_pred)[v])) {
- if (state[v] == i) {
- cycle.addFront((*_pred)[v]);
- for (Node u = _gr->source((*_pred)[v]); u != v;
- u = _gr->source((*_pred)[u])) {
- cycle.addFront((*_pred)[u]);
- }
- return cycle;
- }
- else if (state[v] >= 0) {
- break;
- }
- state[v] = i;
- }
- }
- return cycle;
- }
-
- ///@}
- };
-
- /// \brief Default traits class of bellmanFord() function.
- ///
- /// Default traits class of bellmanFord() function.
- /// \tparam GR The type of the digraph.
- /// \tparam LEN The type of the length map.
- template
- struct BellmanFordWizardDefaultTraits {
- /// The type of the digraph the algorithm runs on.
- typedef GR Digraph;
-
- /// \brief The type of the map that stores the arc lengths.
- ///
- /// The type of the map that stores the arc lengths.
- /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
- typedef LEN LengthMap;
-
- /// The type of the arc lengths.
- typedef typename LEN::Value Value;
-
- /// \brief Operation traits for Bellman-Ford algorithm.
- ///
- /// It defines the used operations and the infinity value for the
- /// given \c Value type.
- /// \see BellmanFordDefaultOperationTraits
- typedef BellmanFordDefaultOperationTraits OperationTraits;
-
- /// \brief The type of the map that stores the last
- /// arcs of the shortest paths.
- ///
- /// The type of the map that stores the last arcs of the shortest paths.
- /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- typedef typename GR::template NodeMap PredMap;
-
- /// \brief Instantiates a \c PredMap.
- ///
- /// This function instantiates a \ref PredMap.
- /// \param g is the digraph to which we would like to define the
- /// \ref PredMap.
- static PredMap *createPredMap(const GR &g) {
- return new PredMap(g);
- }
-
- /// \brief The type of the map that stores the distances of the nodes.
- ///
- /// The type of the map that stores the distances of the nodes.
- /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- typedef typename GR::template NodeMap DistMap;
-
- /// \brief Instantiates a \c DistMap.
- ///
- /// This function instantiates a \ref DistMap.
- /// \param g is the digraph to which we would like to define the
- /// \ref DistMap.
- static DistMap *createDistMap(const GR &g) {
- return new DistMap(g);
- }
-
- ///The type of the shortest paths.
-
- ///The type of the shortest paths.
- ///It must meet the \ref concepts::Path "Path" concept.
- typedef lemon::Path Path;
- };
-
- /// \brief Default traits class used by BellmanFordWizard.
- ///
- /// Default traits class used by BellmanFordWizard.
- /// \tparam GR The type of the digraph.
- /// \tparam LEN The type of the length map.
- template
- class BellmanFordWizardBase
- : public BellmanFordWizardDefaultTraits {
-
- typedef BellmanFordWizardDefaultTraits Base;
- protected:
- // Type of the nodes in the digraph.
- typedef typename Base::Digraph::Node Node;
-
- // Pointer to the underlying digraph.
- void *_graph;
- // Pointer to the length map
- void *_length;
- // Pointer to the map of predecessors arcs.
- void *_pred;
- // Pointer to the map of distances.
- void *_dist;
- //Pointer to the shortest path to the target node.
- void *_path;
- //Pointer to the distance of the target node.
- void *_di;
-
- public:
- /// Constructor.
-
- /// This constructor does not require parameters, it initiates
- /// all of the attributes to default values \c 0.
- BellmanFordWizardBase() :
- _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {}
-
- /// Constructor.
-
- /// This constructor requires two parameters,
- /// others are initiated to \c 0.
- /// \param gr The digraph the algorithm runs on.
- /// \param len The length map.
- BellmanFordWizardBase(const GR& gr,
- const LEN& len) :
- _graph(reinterpret_cast(const_cast(&gr))),
- _length(reinterpret_cast(const_cast(&len))),
- _pred(0), _dist(0), _path(0), _di(0) {}
-
- };
-
- /// \brief Auxiliary class for the function-type interface of the
- /// \ref BellmanFord "Bellman-Ford" algorithm.
- ///
- /// This auxiliary class is created to implement the
- /// \ref bellmanFord() "function-type interface" of the
- /// \ref BellmanFord "Bellman-Ford" algorithm.
- /// It does not have own \ref run() method, it uses the
- /// functions and features of the plain \ref BellmanFord.
- ///
- /// This class should only be used through the \ref bellmanFord()
- /// function, which makes it easier to use the algorithm.
- template
- class BellmanFordWizard : public TR {
- typedef TR Base;
-
- typedef typename TR::Digraph Digraph;
-
- typedef typename Digraph::Node Node;
- typedef typename Digraph::NodeIt NodeIt;
- typedef typename Digraph::Arc Arc;
- typedef typename Digraph::OutArcIt ArcIt;
-
- typedef typename TR::LengthMap LengthMap;
- typedef typename LengthMap::Value Value;
- typedef typename TR::PredMap PredMap;
- typedef typename TR::DistMap DistMap;
- typedef typename TR::Path Path;
-
- public:
- /// Constructor.
- BellmanFordWizard() : TR() {}
-
- /// \brief Constructor that requires parameters.
- ///
- /// Constructor that requires parameters.
- /// These parameters will be the default values for the traits class.
- /// \param gr The digraph the algorithm runs on.
- /// \param len The length map.
- BellmanFordWizard(const Digraph& gr, const LengthMap& len)
- : TR(gr, len) {}
-
- /// \brief Copy constructor
- BellmanFordWizard(const TR &b) : TR(b) {}
-
- ~BellmanFordWizard() {}
-
- /// \brief Runs the Bellman-Ford algorithm from the given source node.
- ///
- /// This method runs the Bellman-Ford algorithm from the given source
- /// node in order to compute the shortest path to each node.
- void run(Node s) {
- BellmanFord
- bf(*reinterpret_cast(Base::_graph),
- *reinterpret_cast(Base::_length));
- if (Base::_pred) bf.predMap(*reinterpret_cast(Base::_pred));
- if (Base::_dist) bf.distMap(*reinterpret_cast(Base::_dist));
- bf.run(s);
- }
-
- /// \brief Runs the Bellman-Ford algorithm to find the shortest path
- /// between \c s and \c t.
- ///
- /// This method runs the Bellman-Ford algorithm from node \c s
- /// in order to compute the shortest path to node \c t.
- /// Actually, it computes the shortest path to each node, but using
- /// this function you can retrieve the distance and the shortest path
- /// for a single target node easier.
- ///
- /// \return \c true if \c t is reachable form \c s.
- bool run(Node s, Node t) {
- BellmanFord
- bf(*reinterpret_cast(Base::_graph),
- *reinterpret_cast(Base::_length));
- if (Base::_pred) bf.predMap(*reinterpret_cast(Base::_pred));
- if (Base::_dist) bf.distMap(*reinterpret_cast(Base::_dist));
- bf.run(s);
- if (Base::_path) *reinterpret_cast(Base::_path) = bf.path(t);
- if (Base::_di) *reinterpret_cast(Base::_di) = bf.dist(t);
- return bf.reached(t);
- }
-
- template
- struct SetPredMapBase : public Base {
- typedef T PredMap;
- static PredMap *createPredMap(const Digraph &) { return 0; };
- SetPredMapBase(const TR &b) : TR(b) {}
- };
-
- /// \brief \ref named-templ-param "Named parameter" for setting
- /// the predecessor map.
- ///
- /// \ref named-templ-param "Named parameter" for setting
- /// the map that stores the predecessor arcs of the nodes.
- template
- BellmanFordWizard > predMap(const T &t) {
- Base::_pred=reinterpret_cast(const_cast(&t));
- return BellmanFordWizard >(*this);
- }
-
- template
- struct SetDistMapBase : public Base {
- typedef T DistMap;
- static DistMap *createDistMap(const Digraph &) { return 0; };
- SetDistMapBase(const TR &b) : TR(b) {}
- };
-
- /// \brief \ref named-templ-param "Named parameter" for setting
- /// the distance map.
- ///
- /// \ref named-templ-param "Named parameter" for setting
- /// the map that stores the distances of the nodes calculated
- /// by the algorithm.
- template
- BellmanFordWizard > distMap(const T &t) {
- Base::_dist=reinterpret_cast(const_cast(&t));
- return BellmanFordWizard >(*this);
- }
-
- template
- struct SetPathBase : public Base {
- typedef T Path;
- SetPathBase(const TR &b) : TR(b) {}
- };
-
- /// \brief \ref named-func-param "Named parameter" for getting
- /// the shortest path to the target node.
- ///
- /// \ref named-func-param "Named parameter" for getting
- /// the shortest path to the target node.
- template
- BellmanFordWizard > path(const T &t)
- {
- Base::_path=reinterpret_cast(const_cast(&t));
- return BellmanFordWizard >(*this);
- }
-
- /// \brief \ref named-func-param "Named parameter" for getting
- /// the distance of the target node.
- ///
- /// \ref named-func-param "Named parameter" for getting
- /// the distance of the target node.
- BellmanFordWizard dist(const Value &d)
- {
- Base::_di=reinterpret_cast(const_cast(&d));
- return *this;
- }
-
- };
-
- /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
- /// algorithm.
- ///
- /// \ingroup shortest_path
- /// Function type interface for the \ref BellmanFord "Bellman-Ford"
- /// algorithm.
- ///
- /// This function also has several \ref named-templ-func-param
- /// "named parameters", they are declared as the members of class
- /// \ref BellmanFordWizard.
- /// The following examples show how to use these parameters.
- /// \code
- /// // Compute shortest path from node s to each node
- /// bellmanFord(g,length).predMap(preds).distMap(dists).run(s);
- ///
- /// // Compute shortest path from s to t
- /// bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t);
- /// \endcode
- /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
- /// to the end of the parameter list.
- /// \sa BellmanFordWizard
- /// \sa BellmanFord
- template
- BellmanFordWizard >
- bellmanFord(const GR& digraph,
- const LEN& length)
- {
- return BellmanFordWizard >(digraph, length);
- }
-
-} //END OF NAMESPACE LEMON
-
-#endif
-
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h (revision 717)
+++ lemon/bfs.h (revision 492)
@@ -48,5 +48,5 @@
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap PredMap;
///Instantiates a \c PredMap.
@@ -63,6 +63,5 @@
///The type of the map that indicates which nodes are processed.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- ///By default it is a NullMap.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef NullMap ProcessedMap;
///Instantiates a \c ProcessedMap.
@@ -83,5 +82,5 @@
///The type of the map that indicates which nodes are reached.
- ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap ReachedMap;
///Instantiates a \c ReachedMap.
@@ -98,5 +97,5 @@
///The type of the map that stores the distances of the nodes.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap DistMap;
///Instantiates a \c DistMap.
@@ -227,5 +226,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c PredMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetPredMap : public Bfs< Digraph, SetPredMapTraits > {
@@ -247,5 +246,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c DistMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetDistMap : public Bfs< Digraph, SetDistMapTraits > {
@@ -267,5 +266,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c ReachedMap type.
- ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
template
struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits > {
@@ -287,5 +286,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c ProcessedMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits > {
@@ -415,6 +414,6 @@
///The simplest way to execute the BFS algorithm is to use one of the
///member functions called \ref run(Node) "run()".\n
- ///If you need better control on the execution, you have to call
- ///\ref init() first, then you can add several source nodes with
+ ///If you need more control on the execution, first you have to call
+ ///\ref init(), then you can add several source nodes with
///\ref addSource(). Finally the actual path computation can be
///performed with one of the \ref start() functions.
@@ -739,7 +738,7 @@
///@{
- ///The shortest path to the given node.
-
- ///Returns the shortest path to the given node from the root(s).
+ ///The shortest path to a node.
+
+ ///Returns the shortest path to a node.
///
///\warning \c t should be reached from the root(s).
@@ -749,7 +748,7 @@
Path path(Node t) const { return Path(*G, *_pred, t); }
- ///The distance of the given node from the root(s).
-
- ///Returns the distance of the given node from the root(s).
+ ///The distance of a node from the root(s).
+
+ ///Returns the distance of a node from the root(s).
///
///\warning If node \c v is not reached from the root(s), then
@@ -760,7 +759,6 @@
int dist(Node v) const { return (*_dist)[v]; }
- ///\brief Returns the 'previous arc' of the shortest path tree for
- ///the given node.
- ///
+ ///Returns the 'previous arc' of the shortest path tree for a node.
+
///This function returns the 'previous arc' of the shortest path
///tree for the node \c v, i.e. it returns the last arc of a
@@ -769,5 +767,5 @@
///
///The shortest path tree used here is equal to the shortest path
- ///tree used in \ref predNode() and \ref predMap().
+ ///tree used in \ref predNode().
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -775,14 +773,13 @@
Arc predArc(Node v) const { return (*_pred)[v];}
- ///\brief Returns the 'previous node' of the shortest path tree for
- ///the given node.
- ///
+ ///Returns the 'previous node' of the shortest path tree for a node.
+
///This function returns the 'previous node' of the shortest path
///tree for the node \c v, i.e. it returns the last but one node
- ///of a shortest path from a root to \c v. It is \c INVALID
+ ///from a shortest path from a root to \c v. It is \c INVALID
///if \c v is not reached from the root(s) or if \c v is a root.
///
///The shortest path tree used here is equal to the shortest path
- ///tree used in \ref predArc() and \ref predMap().
+ ///tree used in \ref predArc().
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -805,5 +802,5 @@
///
///Returns a const reference to the node map that stores the predecessor
- ///arcs, which form the shortest path tree (forest).
+ ///arcs, which form the shortest path tree.
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -811,5 +808,5 @@
const PredMap &predMap() const { return *_pred;}
- ///Checks if the given node is reached from the root(s).
+ ///Checks if a node is reached from the root(s).
///Returns \c true if \c v is reached from the root(s).
@@ -837,5 +834,5 @@
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap PredMap;
///Instantiates a PredMap.
@@ -852,5 +849,5 @@
///The type of the map that indicates which nodes are processed.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap ProcessedMap;
@@ -872,5 +869,5 @@
///The type of the map that indicates which nodes are reached.
- ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap ReachedMap;
///Instantiates a ReachedMap.
@@ -887,5 +884,5 @@
///The type of the map that stores the distances of the nodes.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap DistMap;
///Instantiates a DistMap.
@@ -902,5 +899,5 @@
///The type of the shortest paths.
- ///It must conform to the \ref concepts::Path "Path" concept.
+ ///It must meet the \ref concepts::Path "Path" concept.
typedef lemon::Path Path;
};
@@ -908,6 +905,10 @@
/// Default traits class used by BfsWizard
- /// Default traits class used by BfsWizard.
- /// \tparam GR The type of the digraph.
+ /// To make it easier to use Bfs algorithm
+ /// we have created a wizard class.
+ /// This \ref BfsWizard class needs default traits,
+ /// as well as the \ref Bfs class.
+ /// The \ref BfsWizardBase is a class to be the default traits of the
+ /// \ref BfsWizard class.
template
class BfsWizardBase : public BfsWizardDefaultTraits
@@ -937,5 +938,5 @@
/// Constructor.
- /// This constructor does not require parameters, it initiates
+ /// This constructor does not require parameters, therefore it initiates
/// all of the attributes to \c 0.
BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -967,4 +968,5 @@
typedef TR Base;
+ ///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
@@ -974,8 +976,14 @@
typedef typename Digraph::OutArcIt OutArcIt;
+ ///\brief The type of the map that stores the predecessor
+ ///arcs of the shortest paths.
typedef typename TR::PredMap PredMap;
+ ///\brief The type of the map that stores the distances of the nodes.
typedef typename TR::DistMap DistMap;
+ ///\brief The type of the map that indicates which nodes are reached.
typedef typename TR::ReachedMap ReachedMap;
+ ///\brief The type of the map that indicates which nodes are processed.
typedef typename TR::ProcessedMap ProcessedMap;
+ ///The type of the shortest paths
typedef typename TR::Path Path;
@@ -1060,10 +1068,9 @@
SetPredMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the predecessor map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that stores the predecessor arcs of the nodes.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting PredMap object.
+ ///
+ ///\ref named-func-param "Named parameter"
+ ///for setting PredMap object.
template
BfsWizard > predMap(const T &t)
@@ -1079,10 +1086,9 @@
SetReachedMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the reached map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that indicates which nodes are reached.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting ReachedMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting ReachedMap object.
template
BfsWizard > reachedMap(const T &t)
@@ -1098,11 +1104,9 @@
SetDistMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the distance map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that stores the distances of the nodes calculated
- ///by the algorithm.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting DistMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting DistMap object.
template
BfsWizard > distMap(const T &t)
@@ -1118,10 +1122,9 @@
SetProcessedMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-func-param "Named parameter" for setting
- ///the processed map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that indicates which nodes are processed.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting ProcessedMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting ProcessedMap object.
template
BfsWizard > processedMap(const T &t)
@@ -1262,5 +1265,5 @@
///
/// The type of the map that indicates which nodes are reached.
- /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap ReachedMap;
@@ -1423,6 +1426,6 @@
/// The simplest way to execute the BFS algorithm is to use one of the
/// member functions called \ref run(Node) "run()".\n
- /// If you need better control on the execution, you have to call
- /// \ref init() first, then you can add several source nodes with
+ /// If you need more control on the execution, first you have to call
+ /// \ref init(), then you can add several source nodes with
/// \ref addSource(). Finally the actual path computation can be
/// performed with one of the \ref start() functions.
@@ -1733,5 +1736,5 @@
///@{
- /// \brief Checks if the given node is reached from the root(s).
+ /// \brief Checks if a node is reached from the root(s).
///
/// Returns \c true if \c v is reached from the root(s).
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h (revision 711)
+++ lemon/bin_heap.h (revision 584)
@@ -20,7 +20,7 @@
#define LEMON_BIN_HEAP_H
-///\ingroup heaps
+///\ingroup auxdat
///\file
-///\brief Binary heap implementation.
+///\brief Binary Heap implementation.
#include
@@ -30,39 +30,43 @@
namespace lemon {
- /// \ingroup heaps
+ ///\ingroup auxdat
///
- /// \brief Binary heap data structure.
+ ///\brief A Binary Heap implementation.
///
- /// This class implements the \e binary \e heap data structure.
- /// It fully conforms to the \ref concepts::Heap "heap concept".
+ ///This class implements the \e binary \e heap data structure.
+ ///
+ ///A \e heap is a data structure for storing items with specified values
+ ///called \e priorities in such a way that finding the item with minimum
+ ///priority is efficient. \c Comp specifies the ordering of the priorities.
+ ///In a heap one can change the priority of an item, add or erase an
+ ///item, etc.
///
- /// \tparam PR Type of the priorities of the items.
- /// \tparam IM A read-writable item map with \c int values, used
- /// internally to handle the cross references.
- /// \tparam CMP A functor class for comparing the priorities.
- /// The default is \c std::less.
-#ifdef DOXYGEN
- template
-#else
- template >
-#endif
+ ///\tparam PR Type of the priority of the items.
+ ///\tparam IM A read and writable item map with int values, used internally
+ ///to handle the cross references.
+ ///\tparam Comp A functor class for the ordering of the priorities.
+ ///The default is \c std::less.
+ ///
+ ///\sa FibHeap
+ ///\sa Dijkstra
+ template >
class BinHeap {
+
public:
-
- /// Type of the item-int map.
+ ///\e
typedef IM ItemIntMap;
- /// Type of the priorities.
+ ///\e
typedef PR Prio;
- /// Type of the items stored in the heap.
+ ///\e
typedef typename ItemIntMap::Key Item;
- /// Type of the item-priority pairs.
+ ///\e
typedef std::pair- Pair;
- /// Functor type for comparing the priorities.
- typedef CMP Compare;
-
- /// \brief Type to represent the states of the items.
- ///
- /// Each item has a state associated to it. It can be "in heap",
- /// "pre-heap" or "post-heap". The latter two are indifferent from the
+ ///\e
+ typedef Comp Compare;
+
+ /// \brief Type to represent the items states.
+ ///
+ /// Each Item element have a state associated to it. It may be "in heap",
+ /// "pre heap" or "post heap". The latter two are indifferent from the
/// heap's point of view, but may be useful to the user.
///
@@ -81,41 +85,40 @@
public:
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
+ /// \brief The constructor.
+ ///
+ /// The constructor.
+ /// \param map should be given to the constructor, since it is used
+ /// internally to handle the cross references. The value of the map
+ /// must be \c PRE_HEAP (-1) for every item.
explicit BinHeap(ItemIntMap &map) : _iim(map) {}
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- /// \param comp The function object used for comparing the priorities.
+ /// \brief The constructor.
+ ///
+ /// The constructor.
+ /// \param map should be given to the constructor, since it is used
+ /// internally to handle the cross references. The value of the map
+ /// should be PRE_HEAP (-1) for each element.
+ ///
+ /// \param comp The comparator function object.
BinHeap(ItemIntMap &map, const Compare &comp)
: _iim(map), _comp(comp) {}
- /// \brief The number of items stored in the heap.
- ///
- /// This function returns the number of items stored in the heap.
+ /// The number of items stored in the heap.
+ ///
+ /// \brief Returns the number of items stored in the heap.
int size() const { return _data.size(); }
- /// \brief Check if the heap is empty.
- ///
- /// This function returns \c true if the heap is empty.
+ /// \brief Checks if the heap stores no items.
+ ///
+ /// Returns \c true if and only if the heap stores no items.
bool empty() const { return _data.empty(); }
- /// \brief Make the heap empty.
- ///
- /// This functon makes the heap empty.
- /// It does not change the cross reference map. If you want to reuse
- /// a heap that is not surely empty, you should first clear it and
- /// then you should set the cross reference map to \c PRE_HEAP
- /// for each item.
+ /// \brief Make empty this heap.
+ ///
+ /// Make empty this heap. It does not change the cross reference map.
+ /// If you want to reuse what is not surely empty you should first clear
+ /// the heap and after that you should set the cross reference map for
+ /// each item to \c PRE_HEAP.
void clear() {
_data.clear();
@@ -125,10 +128,10 @@
static int parent(int i) { return (i-1)/2; }
- static int secondChild(int i) { return 2*i+2; }
+ static int second_child(int i) { return 2*i+2; }
bool less(const Pair &p1, const Pair &p2) const {
return _comp(p1.second, p2.second);
}
- int bubbleUp(int hole, Pair p) {
+ int bubble_up(int hole, Pair p) {
int par = parent(hole);
while( hole>0 && less(p,_data[par]) ) {
@@ -141,6 +144,6 @@
}
- int bubbleDown(int hole, Pair p, int length) {
- int child = secondChild(hole);
+ int bubble_down(int hole, Pair p, int length) {
+ int child = second_child(hole);
while(child < length) {
if( less(_data[child-1], _data[child]) ) {
@@ -151,5 +154,5 @@
move(_data[child], hole);
hole = child;
- child = secondChild(hole);
+ child = second_child(hole);
}
child--;
@@ -169,45 +172,42 @@
public:
-
/// \brief Insert a pair of item and priority into the heap.
///
- /// This function inserts \c p.first to the heap with priority
- /// \c p.second.
+ /// Adds \c p.first to the heap with priority \c p.second.
/// \param p The pair to insert.
- /// \pre \c p.first must not be stored in the heap.
void push(const Pair &p) {
int n = _data.size();
_data.resize(n+1);
- bubbleUp(n, p);
- }
-
- /// \brief Insert an item into the heap with the given priority.
- ///
- /// This function inserts the given item into the heap with the
- /// given priority.
+ bubble_up(n, p);
+ }
+
+ /// \brief Insert an item into the heap with the given heap.
+ ///
+ /// Adds \c i to the heap with priority \c p.
/// \param i The item to insert.
/// \param p The priority of the item.
- /// \pre \e i must not be stored in the heap.
void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
- /// \brief Return the item having minimum priority.
- ///
- /// This function returns the item having minimum priority.
- /// \pre The heap must be non-empty.
+ /// \brief Returns the item with minimum priority relative to \c Compare.
+ ///
+ /// This method returns the item with minimum priority relative to \c
+ /// Compare.
+ /// \pre The heap must be nonempty.
Item top() const {
return _data[0].first;
}
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
+ /// \brief Returns the minimum priority relative to \c Compare.
+ ///
+ /// It returns the minimum priority relative to \c Compare.
+ /// \pre The heap must be nonempty.
Prio prio() const {
return _data[0].second;
}
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
+ /// \brief Deletes the item with minimum priority relative to \c Compare.
+ ///
+ /// This method deletes the item with minimum priority relative to \c
+ /// Compare from the heap.
/// \pre The heap must be non-empty.
void pop() {
@@ -215,15 +215,14 @@
_iim.set(_data[0].first, POST_HEAP);
if (n > 0) {
- bubbleDown(0, _data[n], n);
+ bubble_down(0, _data[n], n);
}
_data.pop_back();
}
- /// \brief Remove the given item from the heap.
- ///
- /// This function removes the given item from the heap if it is
- /// already stored.
- /// \param i The item to delete.
- /// \pre \e i must be in the heap.
+ /// \brief Deletes \c i from the heap.
+ ///
+ /// This method deletes item \c i from the heap.
+ /// \param i The item to erase.
+ /// \pre The item should be in the heap.
void erase(const Item &i) {
int h = _iim[i];
@@ -231,6 +230,6 @@
_iim.set(_data[h].first, POST_HEAP);
if( h < n ) {
- if ( bubbleUp(h, _data[n]) == h) {
- bubbleDown(h, _data[n], n);
+ if ( bubble_up(h, _data[n]) == h) {
+ bubble_down(h, _data[n], n);
}
}
@@ -238,9 +237,10 @@
}
- /// \brief The priority of the given item.
- ///
- /// This function returns the priority of the given item.
- /// \param i The item.
- /// \pre \e i must be in the heap.
+
+ /// \brief Returns the priority of \c i.
+ ///
+ /// This function returns the priority of item \c i.
+ /// \param i The item.
+ /// \pre \c i must be in the heap.
Prio operator[](const Item &i) const {
int idx = _iim[i];
@@ -248,10 +248,9 @@
}
- /// \brief Set the priority of an item or insert it, if it is
- /// not stored in the heap.
- ///
- /// This method sets the priority of the given item if it is
- /// already stored in the heap. Otherwise it inserts the given
- /// item into the heap with the given priority.
+ /// \brief \c i gets to the heap with priority \c p independently
+ /// if \c i was already there.
+ ///
+ /// This method calls \ref push(\c i, \c p) if \c i is not stored
+ /// in the heap and sets the priority of \c i to \c p otherwise.
/// \param i The item.
/// \param p The priority.
@@ -262,40 +261,42 @@
}
else if( _comp(p, _data[idx].second) ) {
- bubbleUp(idx, Pair(i,p));
+ bubble_up(idx, Pair(i,p));
}
else {
- bubbleDown(idx, Pair(i,p), _data.size());
- }
- }
-
- /// \brief Decrease the priority of an item to the given value.
- ///
- /// This function decreases the priority of an item to the given value.
+ bubble_down(idx, Pair(i,p), _data.size());
+ }
+ }
+
+ /// \brief Decreases the priority of \c i to \c p.
+ ///
+ /// This method decreases the priority of item \c i to \c p.
/// \param i The item.
/// \param p The priority.
- /// \pre \e i must be stored in the heap with priority at least \e p.
+ /// \pre \c i must be stored in the heap with priority at least \c
+ /// p relative to \c Compare.
void decrease(const Item &i, const Prio &p) {
int idx = _iim[i];
- bubbleUp(idx, Pair(i,p));
- }
-
- /// \brief Increase the priority of an item to the given value.
- ///
- /// This function increases the priority of an item to the given value.
+ bubble_up(idx, Pair(i,p));
+ }
+
+ /// \brief Increases the priority of \c i to \c p.
+ ///
+ /// This method sets the priority of item \c i to \c p.
/// \param i The item.
/// \param p The priority.
- /// \pre \e i must be stored in the heap with priority at most \e p.
+ /// \pre \c i must be stored in the heap with priority at most \c
+ /// p relative to \c Compare.
void increase(const Item &i, const Prio &p) {
int idx = _iim[i];
- bubbleDown(idx, Pair(i,p), _data.size());
- }
-
- /// \brief Return the state of an item.
- ///
- /// This method returns \c PRE_HEAP if the given item has never
- /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
- /// and \c POST_HEAP otherwise.
- /// In the latter case it is possible that the item will get back
- /// to the heap again.
+ bubble_down(idx, Pair(i,p), _data.size());
+ }
+
+ /// \brief Returns if \c item is in, has already been in, or has
+ /// never been in the heap.
+ ///
+ /// This method returns PRE_HEAP if \c item has never been in the
+ /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+ /// otherwise. In the latter case it is possible that \c item will
+ /// get back to the heap again.
/// \param i The item.
State state(const Item &i) const {
@@ -306,9 +307,9 @@
}
- /// \brief Set the state of an item in the heap.
- ///
- /// This function sets the state of the given item in the heap.
- /// It can be used to manually clear the heap when it is important
- /// to achive better time complexity.
+ /// \brief Sets the state of the \c item in the heap.
+ ///
+ /// Sets the state of the \c item in the heap. It can be used to
+ /// manually clear the heap when it is important to achive the
+ /// better time complexity.
/// \param i The item.
/// \param st The state. It should not be \c IN_HEAP.
@@ -327,11 +328,10 @@
}
- /// \brief Replace an item in the heap.
- ///
- /// This function replaces item \c i with item \c j.
- /// Item \c i must be in the heap, while \c j must be out of the heap.
- /// After calling this method, item \c i will be out of the
- /// heap and \c j will be in the heap with the same prioriority
- /// as item \c i had before.
+ /// \brief Replaces an item in the heap.
+ ///
+ /// The \c i item is replaced with \c j item. The \c i item should
+ /// be in the heap, while the \c j should be out of the heap. The
+ /// \c i item will out of the heap and \c j will be in the heap
+ /// with the same prioriority as prevoiusly the \c i item.
void replace(const Item& i, const Item& j) {
int idx = _iim[i];
Index: mon/binom_heap.h
===================================================================
--- lemon/binom_heap.h (revision 707)
+++ (revision )
@@ -1,445 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BINOM_HEAP_H
-#define LEMON_BINOM_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Binomial Heap implementation.
-
-#include
-#include
-#include
-#include
-#include
-
-namespace lemon {
-
- /// \ingroup heaps
- ///
- ///\brief Binomial heap data structure.
- ///
- /// This class implements the \e binomial \e heap data structure.
- /// It fully conforms to the \ref concepts::Heap "heap concept".
- ///
- /// The methods \ref increase() and \ref erase() are not efficient
- /// in a binomial heap. In case of many calls of these operations,
- /// it is better to use other heap structure, e.g. \ref BinHeap
- /// "binary heap".
- ///
- /// \tparam PR Type of the priorities of the items.
- /// \tparam IM A read-writable item map with \c int values, used
- /// internally to handle the cross references.
- /// \tparam CMP A functor class for comparing the priorities.
- /// The default is \c std::less.
-#ifdef DOXYGEN
- template
-#else
- template >
-#endif
- class BinomHeap {
- public:
- /// Type of the item-int map.
- typedef IM ItemIntMap;
- /// Type of the priorities.
- typedef PR Prio;
- /// Type of the items stored in the heap.
- typedef typename ItemIntMap::Key Item;
- /// Functor type for comparing the priorities.
- typedef CMP Compare;
-
- /// \brief Type to represent the states of the items.
- ///
- /// Each item has a state associated to it. It can be "in heap",
- /// "pre-heap" or "post-heap". The latter two are indifferent from the
- /// heap's point of view, but may be useful to the user.
- ///
- /// The item-int map must be initialized in such way that it assigns
- /// \c PRE_HEAP (-1) to any element to be put in the heap.
- enum State {
- IN_HEAP = 0, ///< = 0.
- PRE_HEAP = -1, ///< = -1.
- POST_HEAP = -2 ///< = -2.
- };
-
- private:
- class Store;
-
- std::vector _data;
- int _min, _head;
- ItemIntMap &_iim;
- Compare _comp;
- int _num_items;
-
- public:
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- explicit BinomHeap(ItemIntMap &map)
- : _min(0), _head(-1), _iim(map), _num_items(0) {}
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- /// \param comp The function object used for comparing the priorities.
- BinomHeap(ItemIntMap &map, const Compare &comp)
- : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
-
- /// \brief The number of items stored in the heap.
- ///
- /// This function returns the number of items stored in the heap.
- int size() const { return _num_items; }
-
- /// \brief Check if the heap is empty.
- ///
- /// This function returns \c true if the heap is empty.
- bool empty() const { return _num_items==0; }
-
- /// \brief Make the heap empty.
- ///
- /// This functon makes the heap empty.
- /// It does not change the cross reference map. If you want to reuse
- /// a heap that is not surely empty, you should first clear it and
- /// then you should set the cross reference map to \c PRE_HEAP
- /// for each item.
- void clear() {
- _data.clear(); _min=0; _num_items=0; _head=-1;
- }
-
- /// \brief Set the priority of an item or insert it, if it is
- /// not stored in the heap.
- ///
- /// This method sets the priority of the given item if it is
- /// already stored in the heap. Otherwise it inserts the given
- /// item into the heap with the given priority.
- /// \param item The item.
- /// \param value The priority.
- void set (const Item& item, const Prio& value) {
- int i=_iim[item];
- if ( i >= 0 && _data[i].in ) {
- if ( _comp(value, _data[i].prio) ) decrease(item, value);
- if ( _comp(_data[i].prio, value) ) increase(item, value);
- } else push(item, value);
- }
-
- /// \brief Insert an item into the heap with the given priority.
- ///
- /// This function inserts the given item into the heap with the
- /// given priority.
- /// \param item The item to insert.
- /// \param value The priority of the item.
- /// \pre \e item must not be stored in the heap.
- void push (const Item& item, const Prio& value) {
- int i=_iim[item];
- if ( i<0 ) {
- int s=_data.size();
- _iim.set( item,s );
- Store st;
- st.name=item;
- st.prio=value;
- _data.push_back(st);
- i=s;
- }
- else {
- _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
- _data[i].degree=0;
- _data[i].in=true;
- _data[i].prio=value;
- }
-
- if( 0==_num_items ) {
- _head=i;
- _min=i;
- } else {
- merge(i);
- if( _comp(_data[i].prio, _data[_min].prio) ) _min=i;
- }
- ++_num_items;
- }
-
- /// \brief Return the item having minimum priority.
- ///
- /// This function returns the item having minimum priority.
- /// \pre The heap must be non-empty.
- Item top() const { return _data[_min].name; }
-
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
- Prio prio() const { return _data[_min].prio; }
-
- /// \brief The priority of the given item.
- ///
- /// This function returns the priority of the given item.
- /// \param item The item.
- /// \pre \e item must be in the heap.
- const Prio& operator[](const Item& item) const {
- return _data[_iim[item]].prio;
- }
-
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
- /// \pre The heap must be non-empty.
- void pop() {
- _data[_min].in=false;
-
- int head_child=-1;
- if ( _data[_min].child!=-1 ) {
- int child=_data[_min].child;
- int neighb;
- while( child!=-1 ) {
- neighb=_data[child].right_neighbor;
- _data[child].parent=-1;
- _data[child].right_neighbor=head_child;
- head_child=child;
- child=neighb;
- }
- }
-
- if ( _data[_head].right_neighbor==-1 ) {
- // there was only one root
- _head=head_child;
- }
- else {
- // there were more roots
- if( _head!=_min ) { unlace(_min); }
- else { _head=_data[_head].right_neighbor; }
- merge(head_child);
- }
- _min=findMin();
- --_num_items;
- }
-
- /// \brief Remove the given item from the heap.
- ///
- /// This function removes the given item from the heap if it is
- /// already stored.
- /// \param item The item to delete.
- /// \pre \e item must be in the heap.
- void erase (const Item& item) {
- int i=_iim[item];
- if ( i >= 0 && _data[i].in ) {
- decrease( item, _data[_min].prio-1 );
- pop();
- }
- }
-
- /// \brief Decrease the priority of an item to the given value.
- ///
- /// This function decreases the priority of an item to the given value.
- /// \param item The item.
- /// \param value The priority.
- /// \pre \e item must be stored in the heap with priority at least \e value.
- void decrease (Item item, const Prio& value) {
- int i=_iim[item];
- int p=_data[i].parent;
- _data[i].prio=value;
-
- while( p!=-1 && _comp(value, _data[p].prio) ) {
- _data[i].name=_data[p].name;
- _data[i].prio=_data[p].prio;
- _data[p].name=item;
- _data[p].prio=value;
- _iim[_data[i].name]=i;
- i=p;
- p=_data[p].parent;
- }
- _iim[item]=i;
- if ( _comp(value, _data[_min].prio) ) _min=i;
- }
-
- /// \brief Increase the priority of an item to the given value.
- ///
- /// This function increases the priority of an item to the given value.
- /// \param item The item.
- /// \param value The priority.
- /// \pre \e item must be stored in the heap with priority at most \e value.
- void increase (Item item, const Prio& value) {
- erase(item);
- push(item, value);
- }
-
- /// \brief Return the state of an item.
- ///
- /// This method returns \c PRE_HEAP if the given item has never
- /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
- /// and \c POST_HEAP otherwise.
- /// In the latter case it is possible that the item will get back
- /// to the heap again.
- /// \param item The item.
- State state(const Item &item) const {
- int i=_iim[item];
- if( i>=0 ) {
- if ( _data[i].in ) i=0;
- else i=-2;
- }
- return State(i);
- }
-
- /// \brief Set the state of an item in the heap.
- ///
- /// This function sets the state of the given item in the heap.
- /// It can be used to manually clear the heap when it is important
- /// to achive better time complexity.
- /// \param i The item.
- /// \param st The state. It should not be \c IN_HEAP.
- void state(const Item& i, State st) {
- switch (st) {
- case POST_HEAP:
- case PRE_HEAP:
- if (state(i) == IN_HEAP) {
- erase(i);
- }
- _iim[i] = st;
- break;
- case IN_HEAP:
- break;
- }
- }
-
- private:
-
- // Find the minimum of the roots
- int findMin() {
- if( _head!=-1 ) {
- int min_loc=_head, min_val=_data[_head].prio;
- for( int x=_data[_head].right_neighbor; x!=-1;
- x=_data[x].right_neighbor ) {
- if( _comp( _data[x].prio,min_val ) ) {
- min_val=_data[x].prio;
- min_loc=x;
- }
- }
- return min_loc;
- }
- else return -1;
- }
-
- // Merge the heap with another heap starting at the given position
- void merge(int a) {
- if( _head==-1 || a==-1 ) return;
- if( _data[a].right_neighbor==-1 &&
- _data[a].degree<=_data[_head].degree ) {
- _data[a].right_neighbor=_head;
- _head=a;
- } else {
- interleave(a);
- }
- if( _data[_head].right_neighbor==-1 ) return;
-
- int x=_head;
- int x_prev=-1, x_next=_data[x].right_neighbor;
- while( x_next!=-1 ) {
- if( _data[x].degree!=_data[x_next].degree ||
- ( _data[x_next].right_neighbor!=-1 &&
- _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
- x_prev=x;
- x=x_next;
- }
- else {
- if( _comp(_data[x_next].prio,_data[x].prio) ) {
- if( x_prev==-1 ) {
- _head=x_next;
- } else {
- _data[x_prev].right_neighbor=x_next;
- }
- fuse(x,x_next);
- x=x_next;
- }
- else {
- _data[x].right_neighbor=_data[x_next].right_neighbor;
- fuse(x_next,x);
- }
- }
- x_next=_data[x].right_neighbor;
- }
- }
-
- // Interleave the elements of the given list into the list of the roots
- void interleave(int a) {
- int p=_head, q=a;
- int curr=_data.size();
- _data.push_back(Store());
-
- while( p!=-1 || q!=-1 ) {
- if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
- _data[curr].right_neighbor=p;
- curr=p;
- p=_data[p].right_neighbor;
- }
- else {
- _data[curr].right_neighbor=q;
- curr=q;
- q=_data[q].right_neighbor;
- }
- }
-
- _head=_data.back().right_neighbor;
- _data.pop_back();
- }
-
- // Lace node a under node b
- void fuse(int a, int b) {
- _data[a].parent=b;
- _data[a].right_neighbor=_data[b].child;
- _data[b].child=a;
-
- ++_data[b].degree;
- }
-
- // Unlace node a (if it has siblings)
- void unlace(int a) {
- int neighb=_data[a].right_neighbor;
- int other=_head;
-
- while( _data[other].right_neighbor!=a )
- other=_data[other].right_neighbor;
- _data[other].right_neighbor=neighb;
- }
-
- private:
-
- class Store {
- friend class BinomHeap;
-
- Item name;
- int parent;
- int right_neighbor;
- int child;
- int degree;
- bool in;
- Prio prio;
-
- Store() : parent(-1), right_neighbor(-1), child(-1), degree(0),
- in(true) {}
- };
- };
-
-} //namespace lemon
-
-#endif //LEMON_BINOM_HEAP_H
-
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h (revision 685)
+++ lemon/bits/edge_set_extender.h (revision 617)
@@ -538,5 +538,5 @@
public:
- explicit ArcMap(const Graph& _g)
+ ArcMap(const Graph& _g)
: Parent(_g) {}
ArcMap(const Graph& _g, const _Value& _v)
@@ -562,5 +562,5 @@
public:
- explicit EdgeMap(const Graph& _g)
+ EdgeMap(const Graph& _g)
: Parent(_g) {}
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h (revision 685)
+++ lemon/bits/graph_extender.h (revision 617)
@@ -605,5 +605,5 @@
public:
- explicit NodeMap(const Graph& graph)
+ NodeMap(const Graph& graph)
: Parent(graph) {}
NodeMap(const Graph& graph, const _Value& value)
@@ -629,5 +629,5 @@
public:
- explicit ArcMap(const Graph& graph)
+ ArcMap(const Graph& graph)
: Parent(graph) {}
ArcMap(const Graph& graph, const _Value& value)
@@ -653,5 +653,5 @@
public:
- explicit EdgeMap(const Graph& graph)
+ EdgeMap(const Graph& graph)
: Parent(graph) {}
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h (revision 718)
+++ lemon/bits/map_extender.h (revision 617)
@@ -50,6 +50,4 @@
typedef typename Parent::ConstReference ConstReference;
- typedef typename Parent::ReferenceMapTag ReferenceMapTag;
-
class MapIt;
class ConstMapIt;
@@ -194,6 +192,4 @@
typedef typename Parent::ConstReference ConstReference;
- typedef typename Parent::ReferenceMapTag ReferenceMapTag;
-
class MapIt;
class ConstMapIt;
Index: mon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h (revision 711)
+++ (revision )
@@ -1,594 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BUCKET_HEAP_H
-#define LEMON_BUCKET_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Bucket heap implementation.
-
-#include
-#include
-#include
-
-namespace lemon {
-
- namespace _bucket_heap_bits {
-
- template
- struct DirectionTraits {
- static bool less(int left, int right) {
- return left < right;
- }
- static void increase(int& value) {
- ++value;
- }
- };
-
- template <>
- struct DirectionTraits {
- static bool less(int left, int right) {
- return left > right;
- }
- static void increase(int& value) {
- --value;
- }
- };
-
- }
-
- /// \ingroup heaps
- ///
- /// \brief Bucket heap data structure.
- ///
- /// This class implements the \e bucket \e heap data structure.
- /// It practically conforms to the \ref concepts::Heap "heap concept",
- /// but it has some limitations.
- ///
- /// The bucket heap is a very simple structure. It can store only
- /// \c int priorities and it maintains a list of items for each priority
- /// in the range [0..C). So it should only be used when the
- /// priorities are small. It is not intended to use as a Dijkstra heap.
- ///
- /// \tparam IM A read-writable item map with \c int values, used
- /// internally to handle the cross references.
- /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
- /// The default is \e min-heap. If this parameter is set to \c false,
- /// then the comparison is reversed, so the top(), prio() and pop()
- /// functions deal with the item having maximum priority instead of the
- /// minimum.
- ///
- /// \sa SimpleBucketHeap
- template
- class BucketHeap {
-
- public:
-
- /// Type of the item-int map.
- typedef IM ItemIntMap;
- /// Type of the priorities.
- typedef int Prio;
- /// Type of the items stored in the heap.
- typedef typename ItemIntMap::Key Item;
- /// Type of the item-priority pairs.
- typedef std::pair
- Pair;
-
- private:
-
- typedef _bucket_heap_bits::DirectionTraits Direction;
-
- public:
-
- /// \brief Type to represent the states of the items.
- ///
- /// Each item has a state associated to it. It can be "in heap",
- /// "pre-heap" or "post-heap". The latter two are indifferent from the
- /// heap's point of view, but may be useful to the user.
- ///
- /// The item-int map must be initialized in such way that it assigns
- /// \c PRE_HEAP (-1) to any element to be put in the heap.
- enum State {
- IN_HEAP = 0, ///< = 0.
- PRE_HEAP = -1, ///< = -1.
- POST_HEAP = -2 ///< = -2.
- };
-
- public:
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
-
- /// \brief The number of items stored in the heap.
- ///
- /// This function returns the number of items stored in the heap.
- int size() const { return _data.size(); }
-
- /// \brief Check if the heap is empty.
- ///
- /// This function returns \c true if the heap is empty.
- bool empty() const { return _data.empty(); }
-
- /// \brief Make the heap empty.
- ///
- /// This functon makes the heap empty.
- /// It does not change the cross reference map. If you want to reuse
- /// a heap that is not surely empty, you should first clear it and
- /// then you should set the cross reference map to \c PRE_HEAP
- /// for each item.
- void clear() {
- _data.clear(); _first.clear(); _minimum = 0;
- }
-
- private:
-
- void relocateLast(int idx) {
- if (idx + 1 < int(_data.size())) {
- _data[idx] = _data.back();
- if (_data[idx].prev != -1) {
- _data[_data[idx].prev].next = idx;
- } else {
- _first[_data[idx].value] = idx;
- }
- if (_data[idx].next != -1) {
- _data[_data[idx].next].prev = idx;
- }
- _iim[_data[idx].item] = idx;
- }
- _data.pop_back();
- }
-
- void unlace(int idx) {
- if (_data[idx].prev != -1) {
- _data[_data[idx].prev].next = _data[idx].next;
- } else {
- _first[_data[idx].value] = _data[idx].next;
- }
- if (_data[idx].next != -1) {
- _data[_data[idx].next].prev = _data[idx].prev;
- }
- }
-
- void lace(int idx) {
- if (int(_first.size()) <= _data[idx].value) {
- _first.resize(_data[idx].value + 1, -1);
- }
- _data[idx].next = _first[_data[idx].value];
- if (_data[idx].next != -1) {
- _data[_data[idx].next].prev = idx;
- }
- _first[_data[idx].value] = idx;
- _data[idx].prev = -1;
- }
-
- public:
-
- /// \brief Insert a pair of item and priority into the heap.
- ///
- /// This function inserts \c p.first to the heap with priority
- /// \c p.second.
- /// \param p The pair to insert.
- /// \pre \c p.first must not be stored in the heap.
- void push(const Pair& p) {
- push(p.first, p.second);
- }
-
- /// \brief Insert an item into the heap with the given priority.
- ///
- /// This function inserts the given item into the heap with the
- /// given priority.
- /// \param i The item to insert.
- /// \param p The priority of the item.
- /// \pre \e i must not be stored in the heap.
- void push(const Item &i, const Prio &p) {
- int idx = _data.size();
- _iim[i] = idx;
- _data.push_back(BucketItem(i, p));
- lace(idx);
- if (Direction::less(p, _minimum)) {
- _minimum = p;
- }
- }
-
- /// \brief Return the item having minimum priority.
- ///
- /// This function returns the item having minimum priority.
- /// \pre The heap must be non-empty.
- Item top() const {
- while (_first[_minimum] == -1) {
- Direction::increase(_minimum);
- }
- return _data[_first[_minimum]].item;
- }
-
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
- Prio prio() const {
- while (_first[_minimum] == -1) {
- Direction::increase(_minimum);
- }
- return _minimum;
- }
-
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
- /// \pre The heap must be non-empty.
- void pop() {
- while (_first[_minimum] == -1) {
- Direction::increase(_minimum);
- }
- int idx = _first[_minimum];
- _iim[_data[idx].item] = -2;
- unlace(idx);
- relocateLast(idx);
- }
-
- /// \brief Remove the given item from the heap.
- ///
- /// This function removes the given item from the heap if it is
- /// already stored.
- /// \param i The item to delete.
- /// \pre \e i must be in the heap.
- void erase(const Item &i) {
- int idx = _iim[i];
- _iim[_data[idx].item] = -2;
- unlace(idx);
- relocateLast(idx);
- }
-
- /// \brief The priority of the given item.
- ///
- /// This function returns the priority of the given item.
- /// \param i The item.
- /// \pre \e i must be in the heap.
- Prio operator[](const Item &i) const {
- int idx = _iim[i];
- return _data[idx].value;
- }
-
- /// \brief Set the priority of an item or insert it, if it is
- /// not stored in the heap.
- ///
- /// This method sets the priority of the given item if it is
- /// already stored in the heap. Otherwise it inserts the given
- /// item into the heap with the given priority.
- /// \param i The item.
- /// \param p The priority.
- void set(const Item &i, const Prio &p) {
- int idx = _iim[i];
- if (idx < 0) {
- push(i, p);
- } else if (Direction::less(p, _data[idx].value)) {
- decrease(i, p);
- } else {
- increase(i, p);
- }
- }
-
- /// \brief Decrease the priority of an item to the given value.
- ///
- /// This function decreases the priority of an item to the given value.
- /// \param i The item.
- /// \param p The priority.
- /// \pre \e i must be stored in the heap with priority at least \e p.
- void decrease(const Item &i, const Prio &p) {
- int idx = _iim[i];
- unlace(idx);
- _data[idx].value = p;
- if (Direction::less(p, _minimum)) {
- _minimum = p;
- }
- lace(idx);
- }
-
- /// \brief Increase the priority of an item to the given value.
- ///
- /// This function increases the priority of an item to the given value.
- /// \param i The item.
- /// \param p The priority.
- /// \pre \e i must be stored in the heap with priority at most \e p.
- void increase(const Item &i, const Prio &p) {
- int idx = _iim[i];
- unlace(idx);
- _data[idx].value = p;
- lace(idx);
- }
-
- /// \brief Return the state of an item.
- ///
- /// This method returns \c PRE_HEAP if the given item has never
- /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
- /// and \c POST_HEAP otherwise.
- /// In the latter case it is possible that the item will get back
- /// to the heap again.
- /// \param i The item.
- State state(const Item &i) const {
- int idx = _iim[i];
- if (idx >= 0) idx = 0;
- return State(idx);
- }
-
- /// \brief Set the state of an item in the heap.
- ///
- /// This function sets the state of the given item in the heap.
- /// It can be used to manually clear the heap when it is important
- /// to achive better time complexity.
- /// \param i The item.
- /// \param st The state. It should not be \c IN_HEAP.
- void state(const Item& i, State st) {
- switch (st) {
- case POST_HEAP:
- case PRE_HEAP:
- if (state(i) == IN_HEAP) {
- erase(i);
- }
- _iim[i] = st;
- break;
- case IN_HEAP:
- break;
- }
- }
-
- private:
-
- struct BucketItem {
- BucketItem(const Item& _item, int _value)
- : item(_item), value(_value) {}
-
- Item item;
- int value;
-
- int prev, next;
- };
-
- ItemIntMap& _iim;
- std::vector _first;
- std::vector _data;
- mutable int _minimum;
-
- }; // class BucketHeap
-
- /// \ingroup heaps
- ///
- /// \brief Simplified bucket heap data structure.
- ///
- /// This class implements a simplified \e bucket \e heap data
- /// structure. It does not provide some functionality, but it is
- /// faster and simpler than BucketHeap. The main difference is
- /// that BucketHeap stores a doubly-linked list for each key while
- /// this class stores only simply-linked lists. It supports erasing
- /// only for the item having minimum priority and it does not support
- /// key increasing and decreasing.
- ///
- /// Note that this implementation does not conform to the
- /// \ref concepts::Heap "heap concept" due to the lack of some
- /// functionality.
- ///
- /// \tparam IM A read-writable item map with \c int values, used
- /// internally to handle the cross references.
- /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
- /// The default is \e min-heap. If this parameter is set to \c false,
- /// then the comparison is reversed, so the top(), prio() and pop()
- /// functions deal with the item having maximum priority instead of the
- /// minimum.
- ///
- /// \sa BucketHeap
- template
- class SimpleBucketHeap {
-
- public:
-
- /// Type of the item-int map.
- typedef IM ItemIntMap;
- /// Type of the priorities.
- typedef int Prio;
- /// Type of the items stored in the heap.
- typedef typename ItemIntMap::Key Item;
- /// Type of the item-priority pairs.
- typedef std::pair
- Pair;
-
- private:
-
- typedef _bucket_heap_bits::DirectionTraits Direction;
-
- public:
-
- /// \brief Type to represent the states of the items.
- ///
- /// Each item has a state associated to it. It can be "in heap",
- /// "pre-heap" or "post-heap". The latter two are indifferent from the
- /// heap's point of view, but may be useful to the user.
- ///
- /// The item-int map must be initialized in such way that it assigns
- /// \c PRE_HEAP (-1) to any element to be put in the heap.
- enum State {
- IN_HEAP = 0, ///< = 0.
- PRE_HEAP = -1, ///< = -1.
- POST_HEAP = -2 ///< = -2.
- };
-
- public:
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- explicit SimpleBucketHeap(ItemIntMap &map)
- : _iim(map), _free(-1), _num(0), _minimum(0) {}
-
- /// \brief The number of items stored in the heap.
- ///
- /// This function returns the number of items stored in the heap.
- int size() const { return _num; }
-
- /// \brief Check if the heap is empty.
- ///
- /// This function returns \c true if the heap is empty.
- bool empty() const { return _num == 0; }
-
- /// \brief Make the heap empty.
- ///
- /// This functon makes the heap empty.
- /// It does not change the cross reference map. If you want to reuse
- /// a heap that is not surely empty, you should first clear it and
- /// then you should set the cross reference map to \c PRE_HEAP
- /// for each item.
- void clear() {
- _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
- }
-
- /// \brief Insert a pair of item and priority into the heap.
- ///
- /// This function inserts \c p.first to the heap with priority
- /// \c p.second.
- /// \param p The pair to insert.
- /// \pre \c p.first must not be stored in the heap.
- void push(const Pair& p) {
- push(p.first, p.second);
- }
-
- /// \brief Insert an item into the heap with the given priority.
- ///
- /// This function inserts the given item into the heap with the
- /// given priority.
- /// \param i The item to insert.
- /// \param p The priority of the item.
- /// \pre \e i must not be stored in the heap.
- void push(const Item &i, const Prio &p) {
- int idx;
- if (_free == -1) {
- idx = _data.size();
- _data.push_back(BucketItem(i));
- } else {
- idx = _free;
- _free = _data[idx].next;
- _data[idx].item = i;
- }
- _iim[i] = idx;
- if (p >= int(_first.size())) _first.resize(p + 1, -1);
- _data[idx].next = _first[p];
- _first[p] = idx;
- if (Direction::less(p, _minimum)) {
- _minimum = p;
- }
- ++_num;
- }
-
- /// \brief Return the item having minimum priority.
- ///
- /// This function returns the item having minimum priority.
- /// \pre The heap must be non-empty.
- Item top() const {
- while (_first[_minimum] == -1) {
- Direction::increase(_minimum);
- }
- return _data[_first[_minimum]].item;
- }
-
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
- Prio prio() const {
- while (_first[_minimum] == -1) {
- Direction::increase(_minimum);
- }
- return _minimum;
- }
-
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
- /// \pre The heap must be non-empty.
- void pop() {
- while (_first[_minimum] == -1) {
- Direction::increase(_minimum);
- }
- int idx = _first[_minimum];
- _iim[_data[idx].item] = -2;
- _first[_minimum] = _data[idx].next;
- _data[idx].next = _free;
- _free = idx;
- --_num;
- }
-
- /// \brief The priority of the given item.
- ///
- /// This function returns the priority of the given item.
- /// \param i The item.
- /// \pre \e i must be in the heap.
- /// \warning This operator is not a constant time function because
- /// it scans the whole data structure to find the proper value.
- Prio operator[](const Item &i) const {
- for (int k = 0; k < int(_first.size()); ++k) {
- int idx = _first[k];
- while (idx != -1) {
- if (_data[idx].item == i) {
- return k;
- }
- idx = _data[idx].next;
- }
- }
- return -1;
- }
-
- /// \brief Return the state of an item.
- ///
- /// This method returns \c PRE_HEAP if the given item has never
- /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
- /// and \c POST_HEAP otherwise.
- /// In the latter case it is possible that the item will get back
- /// to the heap again.
- /// \param i The item.
- State state(const Item &i) const {
- int idx = _iim[i];
- if (idx >= 0) idx = 0;
- return State(idx);
- }
-
- private:
-
- struct BucketItem {
- BucketItem(const Item& _item)
- : item(_item) {}
-
- Item item;
- int next;
- };
-
- ItemIntMap& _iim;
- std::vector _first;
- std::vector _data;
- int _free, _num;
- mutable int _minimum;
-
- }; // class SimpleBucketHeap
-
-}
-
-#endif
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc (revision 746)
+++ lemon/cbc.cc (revision 576)
@@ -95,16 +95,4 @@
}
- int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
- std::vector indexes;
- std::vector values;
-
- for(ExprIterator it = b; it != e; ++it) {
- indexes.push_back(it->first);
- values.push_back(it->second);
- }
-
- _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
- return _prob->numberRows() - 1;
- }
void CbcMip::_eraseCol(int i) {
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h (revision 746)
+++ lemon/cbc.h (revision 576)
@@ -63,5 +63,4 @@
virtual int _addCol();
virtual int _addRow();
- virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h (revision 715)
+++ lemon/circulation.h (revision 688)
@@ -73,9 +73,5 @@
/// 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.
@@ -92,10 +88,7 @@
/// The elevator type used by the algorithm.
///
- /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
- typedef lemon::Elevator Elevator;
-#else
+ /// \sa Elevator
+ /// \sa LinkedElevator
typedef lemon::Elevator Elevator;
-#endif
/// \brief Instantiates an Elevator.
@@ -458,8 +451,7 @@
}
- /// \brief Sets the tolerance used by the algorithm.
- ///
- /// Sets the tolerance object used by the algorithm.
- /// \return (*this)
+ /// \brief Sets the tolerance used by algorithm.
+ ///
+ /// Sets the tolerance used by algorithm.
Circulation& tolerance(const Tolerance& tolerance) {
_tol = tolerance;
@@ -469,6 +461,5 @@
/// \brief Returns a const reference to the tolerance.
///
- /// Returns a const reference to the tolerance object used by
- /// the algorithm.
+ /// Returns a const reference to the tolerance.
const Tolerance& tolerance() const {
return _tol;
@@ -477,6 +468,6 @@
/// \name Execution Control
/// The simplest way to execute the algorithm is to call \ref run().\n
- /// If you need better control on the initial solution or the execution,
- /// you have to call one of the \ref init() functions first, then
+ /// If you need more control on the initial solution or the execution,
+ /// first you have to call one of the \ref init() functions, then
/// the \ref start() function.
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc (revision 746)
+++ lemon/clp.cc (revision 576)
@@ -79,17 +79,4 @@
}
- int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
- std::vector indexes;
- std::vector values;
-
- for(ExprIterator it = b; it != e; ++it) {
- indexes.push_back(it->first);
- values.push_back(it->second);
- }
-
- _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
- return _prob->numberRows() - 1;
- }
-
void ClpLp::_eraseCol(int c) {
Index: lemon/clp.h
===================================================================
--- lemon/clp.h (revision 746)
+++ lemon/clp.h (revision 576)
@@ -76,5 +76,4 @@
virtual int _addCol();
virtual int _addRow();
- virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h (revision 734)
+++ lemon/concepts/digraph.h (revision 580)
@@ -36,38 +36,44 @@
/// \brief Class describing the concept of directed graphs.
///
- /// This class describes the common interface of all directed
- /// graphs (digraphs).
+ /// This class describes the \ref concept "concept" of the
+ /// immutable directed digraphs.
///
- /// Like all concept classes, it only provides an interface
- /// without any sensible implementation. So any general algorithm for
- /// directed graphs should compile with this class, but it will not
- /// run properly, of course.
- /// An actual digraph implementation like \ref ListDigraph or
- /// \ref SmartDigraph may have additional functionality.
+ /// Note that actual digraph implementation like @ref ListDigraph or
+ /// @ref SmartDigraph may have several additional functionality.
///
- /// \sa Graph
+ /// \sa concept
class Digraph {
private:
- /// Diraphs are \e not copy constructible. Use DigraphCopy instead.
- Digraph(const Digraph &) {}
- /// \brief Assignment of a digraph to another one is \e not allowed.
- /// Use DigraphCopy instead.
+ ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+
+ ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+ ///
+ Digraph(const Digraph &) {};
+ ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
+ ///\e not allowed. Use DigraphCopy() instead.
+
+ ///Assignment of \ref Digraph "Digraph"s to another ones are
+ ///\e not allowed. Use DigraphCopy() instead.
+
void operator=(const Digraph &) {}
-
public:
- /// Default constructor.
+ ///\e
+
+ /// Defalult constructor.
+
+ /// Defalult constructor.
+ ///
Digraph() { }
-
- /// The node type of the digraph
+ /// Class for identifying a node of the digraph
/// This class identifies a node of the digraph. It also serves
/// as a base class of the node iterators,
- /// thus they convert to this type.
+ /// thus they will convert to this type.
class Node {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the object to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
Node() { }
/// Copy constructor.
@@ -77,37 +83,38 @@
Node(const Node&) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the object to be invalid.
+ /// Invalid constructor \& conversion.
+
+ /// This constructor initializes the iterator to be invalid.
/// \sa Invalid for more details.
Node(Invalid) { }
/// Equality operator
- /// Equality operator.
- ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are \c INVALID.
+ /// same object or both are invalid.
bool operator==(Node) const { return true; }
/// Inequality operator
- /// Inequality operator.
+ /// \sa operator==(Node n)
+ ///
bool operator!=(Node) const { return true; }
/// Artificial ordering operator.
- /// Artificial ordering operator.
- ///
- /// \note This operator only has to define some strict ordering of
- /// the nodes; this order has nothing to do with the iteration
- /// ordering of the nodes.
+ /// To allow the use of digraph descriptors as key type in std::map or
+ /// similar associative container we require this.
+ ///
+ /// \note This operator only have to define some strict ordering of
+ /// the items; this order has nothing to do with the iteration
+ /// ordering of the items.
bool operator<(Node) const { return false; }
- };
-
- /// Iterator class for the nodes.
-
- /// This iterator goes through each node of the digraph.
+
+ };
+
+ /// This iterator goes through each node.
+
+ /// This iterator goes through each node.
/// Its usage is quite simple, for example you can count the number
- /// of nodes in a digraph \c g of type \c %Digraph like this:
+ /// of nodes in digraph \c g of type \c Digraph like this:
///\code
/// int count=0;
@@ -118,6 +125,6 @@
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
NodeIt() { }
/// Copy constructor.
@@ -126,18 +133,20 @@
///
NodeIt(const NodeIt& n) : Node(n) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
+ /// Invalid constructor \& conversion.
+
+ /// Initialize the iterator to be invalid.
/// \sa Invalid for more details.
NodeIt(Invalid) { }
/// Sets the iterator to the first node.
- /// Sets the iterator to the first node of the given digraph.
- ///
- explicit NodeIt(const Digraph&) { }
- /// Sets the iterator to the given node.
-
- /// Sets the iterator to the given node of the given digraph.
- ///
+ /// Sets the iterator to the first node of \c g.
+ ///
+ NodeIt(const Digraph&) { }
+ /// Node -> NodeIt conversion.
+
+ /// Sets the iterator to the node of \c the digraph pointed by
+ /// the trivial iterator.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
NodeIt(const Digraph&, const Node&) { }
/// Next node.
@@ -149,5 +158,5 @@
- /// The arc type of the digraph
+ /// Class for identifying an arc of the digraph
/// This class identifies an arc of the digraph. It also serves
@@ -158,6 +167,6 @@
/// Default constructor
- /// Default constructor.
- /// \warning It sets the object to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
Arc() { }
/// Copy constructor.
@@ -166,32 +175,32 @@
///
Arc(const Arc&) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the object to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
Arc(Invalid) { }
/// Equality operator
- /// Equality operator.
- ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are \c INVALID.
+ /// same object or both are invalid.
bool operator==(Arc) const { return true; }
/// Inequality operator
- /// Inequality operator.
+ /// \sa operator==(Arc n)
+ ///
bool operator!=(Arc) const { return true; }
/// Artificial ordering operator.
- /// Artificial ordering operator.
- ///
- /// \note This operator only has to define some strict ordering of
- /// the arcs; this order has nothing to do with the iteration
- /// ordering of the arcs.
+ /// To allow the use of digraph descriptors as key type in std::map or
+ /// similar associative container we require this.
+ ///
+ /// \note This operator only have to define some strict ordering of
+ /// the items; this order has nothing to do with the iteration
+ /// ordering of the items.
bool operator<(Arc) const { return false; }
};
- /// Iterator class for the outgoing arcs of a node.
+ /// This iterator goes trough the outgoing arcs of a node.
/// This iterator goes trough the \e outgoing arcs of a certain node
@@ -199,15 +208,16 @@
/// Its usage is quite simple, for example you can count the number
/// of outgoing arcs of a node \c n
- /// in a digraph \c g of type \c %Digraph as follows.
+ /// in digraph \c g of type \c Digraph as follows.
///\code
/// int count=0;
- /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+ /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
///\endcode
+
class OutArcIt : public Arc {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
OutArcIt() { }
/// Copy constructor.
@@ -216,20 +226,21 @@
///
OutArcIt(const OutArcIt& e) : Arc(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
OutArcIt(Invalid) { }
- /// Sets the iterator to the first outgoing arc.
-
- /// Sets the iterator to the first outgoing arc of the given node.
- ///
+ /// This constructor sets the iterator to the first outgoing arc.
+
+ /// This constructor sets the iterator to the first outgoing arc of
+ /// the node.
OutArcIt(const Digraph&, const Node&) { }
- /// Sets the iterator to the given arc.
-
- /// Sets the iterator to the given arc of the given digraph.
- ///
+ /// Arc -> OutArcIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
OutArcIt(const Digraph&, const Arc&) { }
- /// Next outgoing arc
+ ///Next outgoing arc
/// Assign the iterator to the next
@@ -238,21 +249,22 @@
};
- /// Iterator class for the incoming arcs of a node.
+ /// This iterator goes trough the incoming arcs of a node.
/// This iterator goes trough the \e incoming arcs of a certain node
/// of a digraph.
/// Its usage is quite simple, for example you can count the number
- /// of incoming arcs of a node \c n
- /// in a digraph \c g of type \c %Digraph as follows.
+ /// of outgoing arcs of a node \c n
+ /// in digraph \c g of type \c Digraph as follows.
///\code
/// int count=0;
- /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+ /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
///\endcode
+
class InArcIt : public Arc {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
InArcIt() { }
/// Copy constructor.
@@ -261,34 +273,34 @@
///
InArcIt(const InArcIt& e) : Arc(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
InArcIt(Invalid) { }
- /// Sets the iterator to the first incoming arc.
-
- /// Sets the iterator to the first incoming arc of the given node.
- ///
+ /// This constructor sets the iterator to first incoming arc.
+
+ /// This constructor set the iterator to the first incoming arc of
+ /// the node.
InArcIt(const Digraph&, const Node&) { }
- /// Sets the iterator to the given arc.
-
- /// Sets the iterator to the given arc of the given digraph.
- ///
+ /// Arc -> InArcIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
InArcIt(const Digraph&, const Arc&) { }
/// Next incoming arc
- /// Assign the iterator to the next
- /// incoming arc of the corresponding node.
+ /// Assign the iterator to the next inarc of the corresponding node.
+ ///
InArcIt& operator++() { return *this; }
};
-
- /// Iterator class for the arcs.
-
- /// This iterator goes through each arc of the digraph.
+ /// This iterator goes through each arc.
+
+ /// This iterator goes through each arc of a digraph.
/// Its usage is quite simple, for example you can count the number
- /// of arcs in a digraph \c g of type \c %Digraph as follows:
+ /// of arcs in a digraph \c g of type \c Digraph as follows:
///\code
/// int count=0;
- /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
+ /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
///\endcode
class ArcIt : public Arc {
@@ -296,6 +308,6 @@
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
ArcIt() { }
/// Copy constructor.
@@ -304,66 +316,56 @@
///
ArcIt(const ArcIt& e) : Arc(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
ArcIt(Invalid) { }
- /// Sets the iterator to the first arc.
-
- /// Sets the iterator to the first arc of the given digraph.
- ///
- explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
- /// Sets the iterator to the given arc.
-
- /// Sets the iterator to the given arc of the given digraph.
- ///
+ /// This constructor sets the iterator to the first arc.
+
+ /// This constructor sets the iterator to the first arc of \c g.
+ ///@param g the digraph
+ ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
+ /// Arc -> ArcIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
ArcIt(const Digraph&, const Arc&) { }
- /// Next arc
+ ///Next arc
/// Assign the iterator to the next arc.
- ///
ArcIt& operator++() { return *this; }
};
-
- /// \brief The source node of the arc.
- ///
- /// Returns the source node of the given arc.
+ ///Gives back the target node of an arc.
+
+ ///Gives back the target node of an arc.
+ ///
+ Node target(Arc) const { return INVALID; }
+ ///Gives back the source node of an arc.
+
+ ///Gives back the source node of an arc.
+ ///
Node source(Arc) const { return INVALID; }
- /// \brief The target node of the arc.
- ///
- /// Returns the target node of the given arc.
- Node target(Arc) const { return INVALID; }
-
- /// \brief The ID of the node.
- ///
- /// Returns the ID of the given node.
+ /// \brief Returns the ID of the node.
int id(Node) const { return -1; }
- /// \brief The ID of the arc.
- ///
- /// Returns the ID of the given arc.
+ /// \brief Returns the ID of the arc.
int id(Arc) const { return -1; }
- /// \brief The node with the given ID.
- ///
- /// Returns the node with the given ID.
- /// \pre The argument should be a valid node ID in the digraph.
+ /// \brief Returns the node with the given ID.
+ ///
+ /// \pre The argument should be a valid node ID in the graph.
Node nodeFromId(int) const { return INVALID; }
- /// \brief The arc with the given ID.
- ///
- /// Returns the arc with the given ID.
- /// \pre The argument should be a valid arc ID in the digraph.
+ /// \brief Returns the arc with the given ID.
+ ///
+ /// \pre The argument should be a valid arc ID in the graph.
Arc arcFromId(int) const { return INVALID; }
- /// \brief An upper bound on the node IDs.
- ///
- /// Returns an upper bound on the node IDs.
+ /// \brief Returns an upper bound on the node IDs.
int maxNodeId() const { return -1; }
- /// \brief An upper bound on the arc IDs.
- ///
- /// Returns an upper bound on the arc IDs.
+ /// \brief Returns an upper bound on the arc IDs.
int maxArcId() const { return -1; }
@@ -391,44 +393,43 @@
int maxId(Arc) const { return -1; }
- /// \brief The opposite node on the arc.
- ///
- /// Returns the opposite node on the given arc.
- Node oppositeNode(Node, Arc) const { return INVALID; }
-
/// \brief The base node of the iterator.
///
- /// Returns the base node of the given outgoing arc iterator
- /// (i.e. the source node of the corresponding arc).
- Node baseNode(OutArcIt) const { return INVALID; }
+ /// Gives back the base node of the iterator.
+ /// It is always the target of the pointed arc.
+ Node baseNode(const InArcIt&) const { return INVALID; }
/// \brief The running node of the iterator.
///
- /// Returns the running node of the given outgoing arc iterator
- /// (i.e. the target node of the corresponding arc).
- Node runningNode(OutArcIt) const { return INVALID; }
+ /// Gives back the running node of the iterator.
+ /// It is always the source of the pointed arc.
+ Node runningNode(const InArcIt&) const { return INVALID; }
/// \brief The base node of the iterator.
///
- /// Returns the base node of the given incomming arc iterator
- /// (i.e. the target node of the corresponding arc).
- Node baseNode(InArcIt) const { return INVALID; }
+ /// Gives back the base node of the iterator.
+ /// It is always the source of the pointed arc.
+ Node baseNode(const OutArcIt&) const { return INVALID; }
/// \brief The running node of the iterator.
///
- /// Returns the running node of the given incomming arc iterator
- /// (i.e. the source node of the corresponding arc).
- Node runningNode(InArcIt) const { return INVALID; }
-
- /// \brief Standard graph map type for the nodes.
- ///
- /// Standard graph map type for the nodes.
- /// It conforms to the ReferenceMap concept.
+ /// Gives back the running node of the iterator.
+ /// It is always the target of the pointed arc.
+ Node runningNode(const OutArcIt&) const { return INVALID; }
+
+ /// \brief The opposite node on the given arc.
+ ///
+ /// Gives back the opposite node on the given arc.
+ Node oppositeNode(const Node&, const Arc&) const { return INVALID; }
+
+ /// \brief Reference map of the nodes to type \c T.
+ ///
+ /// Reference map of the nodes to type \c T.
template
class NodeMap : public ReferenceMap {
public:
- /// Constructor
- explicit NodeMap(const Digraph&) { }
- /// Constructor with given initial value
+ ///\e
+ NodeMap(const Digraph&) { }
+ ///\e
NodeMap(const Digraph&, T) { }
@@ -445,17 +446,15 @@
};
- /// \brief Standard graph map type for the arcs.
- ///
- /// Standard graph map type for the arcs.
- /// It conforms to the ReferenceMap concept.
+ /// \brief Reference map of the arcs to type \c T.
+ ///
+ /// Reference map of the arcs to type \c T.
template
class ArcMap : public ReferenceMap {
public:
- /// Constructor
- explicit ArcMap(const Digraph&) { }
- /// Constructor with given initial value
+ ///\e
+ ArcMap(const Digraph&) { }
+ ///\e
ArcMap(const Digraph&, T) { }
-
private:
///Copy constructor
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h (revision 734)
+++ lemon/concepts/graph.h (revision 657)
@@ -19,5 +19,5 @@
///\ingroup graph_concepts
///\file
-///\brief The concept of undirected graphs.
+///\brief The concept of Undirected Graphs.
#ifndef LEMON_CONCEPTS_GRAPH_H
@@ -25,6 +25,4 @@
#include
-#include
-#include
#include
@@ -34,72 +32,61 @@
/// \ingroup graph_concepts
///
- /// \brief Class describing the concept of undirected graphs.
+ /// \brief Class describing the concept of Undirected Graphs.
///
- /// This class describes the common interface of all undirected
- /// graphs.
+ /// This class describes the common interface of all Undirected
+ /// Graphs.
///
- /// Like all concept classes, it only provides an interface
- /// without any sensible implementation. So any general algorithm for
- /// undirected graphs should compile with this class, but it will not
+ /// As all concept describing classes it provides only interface
+ /// without any sensible implementation. So any algorithm for
+ /// undirected graph should compile with this class, but it will not
/// run properly, of course.
- /// An actual graph implementation like \ref ListGraph or
- /// \ref SmartGraph may have additional functionality.
///
- /// The undirected graphs also fulfill the concept of \ref Digraph
- /// "directed graphs", since each edge can also be regarded as two
- /// oppositely directed arcs.
- /// Undirected graphs provide an Edge type for the undirected edges and
- /// an Arc type for the directed arcs. The Arc type is convertible to
- /// Edge or inherited from it, i.e. the corresponding edge can be
- /// obtained from an arc.
- /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt
- /// and ArcMap classes can be used for the arcs (just like in digraphs).
- /// Both InArcIt and OutArcIt iterates on the same edges but with
- /// opposite direction. IncEdgeIt also iterates on the same edges
- /// as OutArcIt and InArcIt, but it is not convertible to Arc,
- /// only to Edge.
+ /// The LEMON undirected graphs also fulfill the concept of
+ /// directed graphs (\ref lemon::concepts::Digraph "Digraph
+ /// Concept"). Each edges can be seen as two opposite
+ /// directed arc and consequently the undirected graph can be
+ /// seen as the direceted graph of these directed arcs. The
+ /// Graph has the Edge inner class for the edges and
+ /// the Arc type for the directed arcs. The Arc type is
+ /// convertible to Edge or inherited from it so from a directed
+ /// arc we can get the represented edge.
///
- /// In LEMON, each undirected edge has an inherent orientation.
- /// Thus it can defined if an arc is forward or backward oriented in
- /// an undirected graph with respect to this default oriantation of
- /// the represented edge.
- /// With the direction() and direct() functions the direction
- /// of an arc can be obtained and set, respectively.
+ /// In the sense of the LEMON each edge has a default
+ /// direction (it should be in every computer implementation,
+ /// because the order of edge's nodes defines an
+ /// orientation). With the default orientation we can define that
+ /// the directed arc is forward or backward directed. With the \c
+ /// direction() and \c direct() function we can get the direction
+ /// of the directed arc and we can direct an edge.
///
- /// Only nodes and edges can be added to or removed from an undirected
- /// graph and the corresponding arcs are added or removed automatically.
- ///
- /// \sa Digraph
+ /// The EdgeIt is an iterator for the edges. We can use
+ /// the EdgeMap to map values for the edges. The InArcIt and
+ /// OutArcIt iterates on the same edges but with opposite
+ /// direction. The IncEdgeIt iterates also on the same edges
+ /// as the OutArcIt and InArcIt but it is not convertible to Arc just
+ /// to Edge.
class Graph {
- private:
- /// Graphs are \e not copy constructible. Use DigraphCopy instead.
- Graph(const Graph&) {}
- /// \brief Assignment of a graph to another one is \e not allowed.
- /// Use DigraphCopy instead.
- void operator=(const Graph&) {}
-
public:
- /// Default constructor.
- Graph() {}
-
- /// \brief Undirected graphs should be tagged with \c UndirectedTag.
- ///
- /// Undirected graphs should be tagged with \c UndirectedTag.
- ///
- /// This tag helps the \c enable_if technics to make compile time
+ /// \brief The undirected graph should be tagged by the
+ /// UndirectedTag.
+ ///
+ /// The undirected graph should be tagged by the UndirectedTag. This
+ /// tag helps the enable_if technics to make compile time
/// specializations for undirected graphs.
typedef True UndirectedTag;
- /// The node type of the graph
-
- /// This class identifies a node of the graph. It also serves
- /// as a base class of the node iterators,
- /// thus they convert to this type.
+ /// \brief The base type of node iterators,
+ /// or in other words, the trivial node iterator.
+ ///
+ /// This is the base type of each node iterator,
+ /// thus each kind of node iterator converts to this.
+ /// More precisely each kind of node iterator should be inherited
+ /// from the trivial node iterator.
class Node {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the object to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
Node() { }
/// Copy constructor.
@@ -109,27 +96,27 @@
Node(const Node&) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the object to be invalid.
+ /// Invalid constructor \& conversion.
+
+ /// This constructor initializes the iterator to be invalid.
/// \sa Invalid for more details.
Node(Invalid) { }
/// Equality operator
- /// Equality operator.
- ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are \c INVALID.
+ /// same object or both are invalid.
bool operator==(Node) const { return true; }
/// Inequality operator
- /// Inequality operator.
+ /// \sa operator==(Node n)
+ ///
bool operator!=(Node) const { return true; }
/// Artificial ordering operator.
- /// Artificial ordering operator.
- ///
- /// \note This operator only has to define some strict ordering of
+ /// To allow the use of graph descriptors as key type in std::map or
+ /// similar associative container we require this.
+ ///
+ /// \note This operator only have to define some strict ordering of
/// the items; this order has nothing to do with the iteration
/// ordering of the items.
@@ -138,9 +125,9 @@
};
- /// Iterator class for the nodes.
-
- /// This iterator goes through each node of the graph.
+ /// This iterator goes through each node.
+
+ /// This iterator goes through each node.
/// Its usage is quite simple, for example you can count the number
- /// of nodes in a graph \c g of type \c %Graph like this:
+ /// of nodes in graph \c g of type \c Graph like this:
///\code
/// int count=0;
@@ -151,6 +138,6 @@
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
NodeIt() { }
/// Copy constructor.
@@ -159,18 +146,20 @@
///
NodeIt(const NodeIt& n) : Node(n) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
+ /// Invalid constructor \& conversion.
+
+ /// Initialize the iterator to be invalid.
/// \sa Invalid for more details.
NodeIt(Invalid) { }
/// Sets the iterator to the first node.
- /// Sets the iterator to the first node of the given digraph.
- ///
- explicit NodeIt(const Graph&) { }
- /// Sets the iterator to the given node.
-
- /// Sets the iterator to the given node of the given digraph.
- ///
+ /// Sets the iterator to the first node of \c g.
+ ///
+ NodeIt(const Graph&) { }
+ /// Node -> NodeIt conversion.
+
+ /// Sets the iterator to the node of \c the graph pointed by
+ /// the trivial iterator.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
NodeIt(const Graph&, const Node&) { }
/// Next node.
@@ -182,15 +171,14 @@
- /// The edge type of the graph
-
- /// This class identifies an edge of the graph. It also serves
- /// as a base class of the edge iterators,
- /// thus they will convert to this type.
+ /// The base type of the edge iterators.
+
+ /// The base type of the edge iterators.
+ ///
class Edge {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the object to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
Edge() { }
/// Copy constructor.
@@ -199,36 +187,36 @@
///
Edge(const Edge&) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the object to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
Edge(Invalid) { }
/// Equality operator
- /// Equality operator.
- ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are \c INVALID.
+ /// same object or both are invalid.
bool operator==(Edge) const { return true; }
/// Inequality operator
- /// Inequality operator.
+ /// \sa operator==(Edge n)
+ ///
bool operator!=(Edge) const { return true; }
/// Artificial ordering operator.
- /// Artificial ordering operator.
- ///
- /// \note This operator only has to define some strict ordering of
- /// the edges; this order has nothing to do with the iteration
- /// ordering of the edges.
+ /// To allow the use of graph descriptors as key type in std::map or
+ /// similar associative container we require this.
+ ///
+ /// \note This operator only have to define some strict ordering of
+ /// the items; this order has nothing to do with the iteration
+ /// ordering of the items.
bool operator<(Edge) const { return false; }
};
- /// Iterator class for the edges.
-
- /// This iterator goes through each edge of the graph.
+ /// This iterator goes through each edge.
+
+ /// This iterator goes through each edge of a graph.
/// Its usage is quite simple, for example you can count the number
- /// of edges in a graph \c g of type \c %Graph as follows:
+ /// of edges in a graph \c g of type \c Graph as follows:
///\code
/// int count=0;
@@ -239,6 +227,6 @@
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
EdgeIt() { }
/// Copy constructor.
@@ -247,33 +235,36 @@
///
EdgeIt(const EdgeIt& e) : Edge(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
EdgeIt(Invalid) { }
- /// Sets the iterator to the first edge.
-
- /// Sets the iterator to the first edge of the given graph.
- ///
- explicit EdgeIt(const Graph&) { }
- /// Sets the iterator to the given edge.
-
- /// Sets the iterator to the given edge of the given graph.
- ///
+ /// This constructor sets the iterator to the first edge.
+
+ /// This constructor sets the iterator to the first edge.
+ EdgeIt(const Graph&) { }
+ /// Edge -> EdgeIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator.
+ /// This feature necessitates that each time we
+ /// iterate the edge-set, the iteration order is the
+ /// same.
EdgeIt(const Graph&, const Edge&) { }
/// Next edge
/// Assign the iterator to the next edge.
- ///
EdgeIt& operator++() { return *this; }
};
- /// Iterator class for the incident edges of a node.
-
- /// This iterator goes trough the incident undirected edges
- /// of a certain node of a graph.
+ /// \brief This iterator goes trough the incident undirected
+ /// arcs of a node.
+ ///
+ /// This iterator goes trough the incident edges
+ /// of a certain node of a graph. You should assume that the
+ /// loop arcs will be iterated twice.
+ ///
/// Its usage is quite simple, for example you can compute the
- /// degree (i.e. the number of incident edges) of a node \c n
- /// in a graph \c g of type \c %Graph as follows.
+ /// degree (i.e. count the number of incident arcs of a node \c n
+ /// in graph \c g of type \c Graph as follows.
///
///\code
@@ -281,12 +272,10 @@
/// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
///\endcode
- ///
- /// \warning Loop edges will be iterated twice.
class IncEdgeIt : public Edge {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
IncEdgeIt() { }
/// Copy constructor.
@@ -295,37 +284,38 @@
///
IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
IncEdgeIt(Invalid) { }
- /// Sets the iterator to the first incident edge.
-
- /// Sets the iterator to the first incident edge of the given node.
- ///
+ /// This constructor sets the iterator to first incident arc.
+
+ /// This constructor set the iterator to the first incident arc of
+ /// the node.
IncEdgeIt(const Graph&, const Node&) { }
- /// Sets the iterator to the given edge.
-
- /// Sets the iterator to the given edge of the given graph.
- ///
+ /// Edge -> IncEdgeIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
IncEdgeIt(const Graph&, const Edge&) { }
- /// Next incident edge
-
- /// Assign the iterator to the next incident edge
+ /// Next incident arc
+
+ /// Assign the iterator to the next incident arc
/// of the corresponding node.
IncEdgeIt& operator++() { return *this; }
};
- /// The arc type of the graph
-
- /// This class identifies a directed arc of the graph. It also serves
- /// as a base class of the arc iterators,
- /// thus they will convert to this type.
+ /// The directed arc type.
+
+ /// The directed arc type. It can be converted to the
+ /// edge or it should be inherited from the undirected
+ /// edge.
class Arc {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the object to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
Arc() { }
/// Copy constructor.
@@ -334,45 +324,41 @@
///
Arc(const Arc&) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the object to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
Arc(Invalid) { }
/// Equality operator
- /// Equality operator.
- ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are \c INVALID.
+ /// same object or both are invalid.
bool operator==(Arc) const { return true; }
/// Inequality operator
- /// Inequality operator.
+ /// \sa operator==(Arc n)
+ ///
bool operator!=(Arc) const { return true; }
/// Artificial ordering operator.
- /// Artificial ordering operator.
- ///
- /// \note This operator only has to define some strict ordering of
- /// the arcs; this order has nothing to do with the iteration
- /// ordering of the arcs.
+ /// To allow the use of graph descriptors as key type in std::map or
+ /// similar associative container we require this.
+ ///
+ /// \note This operator only have to define some strict ordering of
+ /// the items; this order has nothing to do with the iteration
+ /// ordering of the items.
bool operator<(Arc) const { return false; }
- /// Converison to \c Edge
-
- /// Converison to \c Edge.
- ///
+ /// Converison to Edge
operator Edge() const { return Edge(); }
};
-
- /// Iterator class for the arcs.
-
- /// This iterator goes through each directed arc of the graph.
+ /// This iterator goes through each directed arc.
+
+ /// This iterator goes through each arc of a graph.
/// Its usage is quite simple, for example you can count the number
- /// of arcs in a graph \c g of type \c %Graph as follows:
+ /// of arcs in a graph \c g of type \c Graph as follows:
///\code
/// int count=0;
- /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
+ /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
///\endcode
class ArcIt : public Arc {
@@ -380,6 +366,6 @@
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
ArcIt() { }
/// Copy constructor.
@@ -388,43 +374,44 @@
///
ArcIt(const ArcIt& e) : Arc(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
ArcIt(Invalid) { }
- /// Sets the iterator to the first arc.
-
- /// Sets the iterator to the first arc of the given graph.
- ///
- explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
- /// Sets the iterator to the given arc.
-
- /// Sets the iterator to the given arc of the given graph.
- ///
+ /// This constructor sets the iterator to the first arc.
+
+ /// This constructor sets the iterator to the first arc of \c g.
+ ///@param g the graph
+ ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
+ /// Arc -> ArcIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
ArcIt(const Graph&, const Arc&) { }
- /// Next arc
+ ///Next arc
/// Assign the iterator to the next arc.
- ///
ArcIt& operator++() { return *this; }
};
- /// Iterator class for the outgoing arcs of a node.
-
- /// This iterator goes trough the \e outgoing directed arcs of a
- /// certain node of a graph.
+ /// This iterator goes trough the outgoing directed arcs of a node.
+
+ /// This iterator goes trough the \e outgoing arcs of a certain node
+ /// of a graph.
/// Its usage is quite simple, for example you can count the number
/// of outgoing arcs of a node \c n
- /// in a graph \c g of type \c %Graph as follows.
+ /// in graph \c g of type \c Graph as follows.
///\code
/// int count=0;
- /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+ /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
///\endcode
+
class OutArcIt : public Arc {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
OutArcIt() { }
/// Copy constructor.
@@ -433,23 +420,26 @@
///
OutArcIt(const OutArcIt& e) : Arc(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
OutArcIt(Invalid) { }
- /// Sets the iterator to the first outgoing arc.
-
- /// Sets the iterator to the first outgoing arc of the given node.
- ///
+ /// This constructor sets the iterator to the first outgoing arc.
+
+ /// This constructor sets the iterator to the first outgoing arc of
+ /// the node.
+ ///@param n the node
+ ///@param g the graph
OutArcIt(const Graph& n, const Node& g) {
ignore_unused_variable_warning(n);
ignore_unused_variable_warning(g);
}
- /// Sets the iterator to the given arc.
-
- /// Sets the iterator to the given arc of the given graph.
- ///
+ /// Arc -> OutArcIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
OutArcIt(const Graph&, const Arc&) { }
- /// Next outgoing arc
+ ///Next outgoing arc
/// Assign the iterator to the next
@@ -458,21 +448,22 @@
};
- /// Iterator class for the incoming arcs of a node.
-
- /// This iterator goes trough the \e incoming directed arcs of a
- /// certain node of a graph.
+ /// This iterator goes trough the incoming directed arcs of a node.
+
+ /// This iterator goes trough the \e incoming arcs of a certain node
+ /// of a graph.
/// Its usage is quite simple, for example you can count the number
- /// of incoming arcs of a node \c n
- /// in a graph \c g of type \c %Graph as follows.
+ /// of outgoing arcs of a node \c n
+ /// in graph \c g of type \c Graph as follows.
///\code
/// int count=0;
- /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+ /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
///\endcode
+
class InArcIt : public Arc {
public:
/// Default constructor
- /// Default constructor.
- /// \warning It sets the iterator to an undefined value.
+ /// @warning The default constructor sets the iterator
+ /// to an undefined value.
InArcIt() { }
/// Copy constructor.
@@ -481,33 +472,35 @@
///
InArcIt(const InArcIt& e) : Arc(e) { }
- /// %Invalid constructor \& conversion.
-
- /// Initializes the iterator to be invalid.
- /// \sa Invalid for more details.
+ /// Initialize the iterator to be invalid.
+
+ /// Initialize the iterator to be invalid.
+ ///
InArcIt(Invalid) { }
- /// Sets the iterator to the first incoming arc.
-
- /// Sets the iterator to the first incoming arc of the given node.
- ///
+ /// This constructor sets the iterator to first incoming arc.
+
+ /// This constructor set the iterator to the first incoming arc of
+ /// the node.
+ ///@param n the node
+ ///@param g the graph
InArcIt(const Graph& g, const Node& n) {
ignore_unused_variable_warning(n);
ignore_unused_variable_warning(g);
}
- /// Sets the iterator to the given arc.
-
- /// Sets the iterator to the given arc of the given graph.
- ///
+ /// Arc -> InArcIt conversion
+
+ /// Sets the iterator to the value of the trivial iterator \c e.
+ /// This feature necessitates that each time we
+ /// iterate the arc-set, the iteration order is the same.
InArcIt(const Graph&, const Arc&) { }
/// Next incoming arc
- /// Assign the iterator to the next
- /// incoming arc of the corresponding node.
+ /// Assign the iterator to the next inarc of the corresponding node.
+ ///
InArcIt& operator++() { return *this; }
};
- /// \brief Standard graph map type for the nodes.
- ///
- /// Standard graph map type for the nodes.
- /// It conforms to the ReferenceMap concept.
+ /// \brief Reference map of the nodes to type \c T.
+ ///
+ /// Reference map of the nodes to type \c T.
template
class NodeMap : public ReferenceMap
@@ -515,7 +508,7 @@
public:
- /// Constructor
- explicit NodeMap(const Graph&) { }
- /// Constructor with given initial value
+ ///\e
+ NodeMap(const Graph&) { }
+ ///\e
NodeMap(const Graph&, T) { }
@@ -532,8 +525,7 @@
};
- /// \brief Standard graph map type for the arcs.
- ///
- /// Standard graph map type for the arcs.
- /// It conforms to the ReferenceMap concept.
+ /// \brief Reference map of the arcs to type \c T.
+ ///
+ /// Reference map of the arcs to type \c T.
template
class ArcMap : public ReferenceMap
@@ -541,9 +533,8 @@
public:
- /// Constructor
- explicit ArcMap(const Graph&) { }
- /// Constructor with given initial value
+ ///\e
+ ArcMap(const Graph&) { }
+ ///\e
ArcMap(const Graph&, T) { }
-
private:
///Copy constructor
@@ -558,8 +549,7 @@
};
- /// \brief Standard graph map type for the edges.
- ///
- /// Standard graph map type for the edges.
- /// It conforms to the ReferenceMap concept.
+ /// Reference map of the edges to type \c T.
+
+ /// Reference map of the edges to type \c T.
template
class EdgeMap : public ReferenceMap
@@ -567,9 +557,8 @@
public:
- /// Constructor
- explicit EdgeMap(const Graph&) { }
- /// Constructor with given initial value
+ ///\e
+ EdgeMap(const Graph&) { }
+ ///\e
EdgeMap(const Graph&, T) { }
-
private:
///Copy constructor
@@ -584,121 +573,104 @@
};
- /// \brief The first node of the edge.
- ///
- /// Returns the first node of the given edge.
- ///
- /// Edges don't have source and target nodes, however methods
- /// u() and v() are used to query the two end-nodes of an edge.
- /// The orientation of an edge that arises this way is called
- /// the inherent direction, it is used to define the default
- /// direction for the corresponding arcs.
+ /// \brief Direct the given edge.
+ ///
+ /// Direct the given edge. The returned arc source
+ /// will be the given node.
+ Arc direct(const Edge&, const Node&) const {
+ return INVALID;
+ }
+
+ /// \brief Direct the given edge.
+ ///
+ /// Direct the given edge. The returned arc
+ /// represents the given edge and the direction comes
+ /// from the bool parameter. The source of the edge and
+ /// the directed arc is the same when the given bool is true.
+ Arc direct(const Edge&, bool) const {
+ return INVALID;
+ }
+
+ /// \brief Returns true if the arc has default orientation.
+ ///
+ /// Returns whether the given directed arc is same orientation as
+ /// the corresponding edge's default orientation.
+ bool direction(Arc) const { return true; }
+
+ /// \brief Returns the opposite directed arc.
+ ///
+ /// Returns the opposite directed arc.
+ Arc oppositeArc(Arc) const { return INVALID; }
+
+ /// \brief Opposite node on an arc
+ ///
+ /// \return The opposite of the given node on the given edge.
+ Node oppositeNode(Node, Edge) const { return INVALID; }
+
+ /// \brief First node of the edge.
+ ///
+ /// \return The first node of the given edge.
+ ///
+ /// Naturally edges don't have direction and thus
+ /// don't have source and target node. However we use \c u() and \c v()
+ /// methods to query the two nodes of the arc. The direction of the
+ /// arc which arises this way is called the inherent direction of the
+ /// edge, and is used to define the "default" direction
+ /// of the directed versions of the arcs.
/// \sa v()
/// \sa direction()
Node u(Edge) const { return INVALID; }
- /// \brief The second node of the edge.
- ///
- /// Returns the second node of the given edge.
- ///
- /// Edges don't have source and target nodes, however methods
- /// u() and v() are used to query the two end-nodes of an edge.
- /// The orientation of an edge that arises this way is called
- /// the inherent direction, it is used to define the default
- /// direction for the corresponding arcs.
+ /// \brief Second node of the edge.
+ ///
+ /// \return The second node of the given edge.
+ ///
+ /// Naturally edges don't have direction and thus
+ /// don't have source and target node. However we use \c u() and \c v()
+ /// methods to query the two nodes of the arc. The direction of the
+ /// arc which arises this way is called the inherent direction of the
+ /// edge, and is used to define the "default" direction
+ /// of the directed versions of the arcs.
/// \sa u()
/// \sa direction()
Node v(Edge) const { return INVALID; }
- /// \brief The source node of the arc.
- ///
- /// Returns the source node of the given arc.
+ /// \brief Source node of the directed arc.
Node source(Arc) const { return INVALID; }
- /// \brief The target node of the arc.
- ///
- /// Returns the target node of the given arc.
+ /// \brief Target node of the directed arc.
Node target(Arc) const { return INVALID; }
- /// \brief The ID of the node.
- ///
- /// Returns the ID of the given node.
+ /// \brief Returns the id of the node.
int id(Node) const { return -1; }
- /// \brief The ID of the edge.
- ///
- /// Returns the ID of the given edge.
+ /// \brief Returns the id of the edge.
int id(Edge) const { return -1; }
- /// \brief The ID of the arc.
- ///
- /// Returns the ID of the given arc.
+ /// \brief Returns the id of the arc.
int id(Arc) const { return -1; }
- /// \brief The node with the given ID.
- ///
- /// Returns the node with the given ID.
- /// \pre The argument should be a valid node ID in the graph.
+ /// \brief Returns the node with the given id.
+ ///
+ /// \pre The argument should be a valid node id in the graph.
Node nodeFromId(int) const { return INVALID; }
- /// \brief The edge with the given ID.
- ///
- /// Returns the edge with the given ID.
- /// \pre The argument should be a valid edge ID in the graph.
+ /// \brief Returns the edge with the given id.
+ ///
+ /// \pre The argument should be a valid edge id in the graph.
Edge edgeFromId(int) const { return INVALID; }
- /// \brief The arc with the given ID.
- ///
- /// Returns the arc with the given ID.
- /// \pre The argument should be a valid arc ID in the graph.
+ /// \brief Returns the arc with the given id.
+ ///
+ /// \pre The argument should be a valid arc id in the graph.
Arc arcFromId(int) const { return INVALID; }
- /// \brief An upper bound on the node IDs.
- ///
- /// Returns an upper bound on the node IDs.
+ /// \brief Returns an upper bound on the node IDs.
int maxNodeId() const { return -1; }
- /// \brief An upper bound on the edge IDs.
- ///
- /// Returns an upper bound on the edge IDs.
+ /// \brief Returns an upper bound on the edge IDs.
int maxEdgeId() const { return -1; }
- /// \brief An upper bound on the arc IDs.
- ///
- /// Returns an upper bound on the arc IDs.
+ /// \brief Returns an upper bound on the arc IDs.
int maxArcId() const { return -1; }
-
- /// \brief The direction of the arc.
- ///
- /// Returns \c true if the direction of the given arc is the same as
- /// the inherent orientation of the represented edge.
- bool direction(Arc) const { return true; }
-
- /// \brief Direct the edge.
- ///
- /// Direct the given edge. The returned arc
- /// represents the given edge and its direction comes
- /// from the bool parameter. If it is \c true, then the direction
- /// of the arc is the same as the inherent orientation of the edge.
- Arc direct(Edge, bool) const {
- return INVALID;
- }
-
- /// \brief Direct the edge.
- ///
- /// Direct the given edge. The returned arc represents the given
- /// edge and its source node is the given node.
- Arc direct(Edge, Node) const {
- return INVALID;
- }
-
- /// \brief The oppositely directed arc.
- ///
- /// Returns the oppositely directed arc representing the same edge.
- Arc oppositeArc(Arc) const { return INVALID; }
-
- /// \brief The opposite node on the edge.
- ///
- /// Returns the opposite node on the given edge.
- Node oppositeNode(Node, Edge) const { return INVALID; }
void first(Node&) const {}
@@ -734,37 +706,45 @@
int maxId(Arc) const { return -1; }
- /// \brief The base node of the iterator.
- ///
- /// Returns the base node of the given incident edge iterator.
- Node baseNode(IncEdgeIt) const { return INVALID; }
-
- /// \brief The running node of the iterator.
- ///
- /// Returns the running node of the given incident edge iterator.
- Node runningNode(IncEdgeIt) const { return INVALID; }
-
- /// \brief The base node of the iterator.
- ///
- /// Returns the base node of the given outgoing arc iterator
- /// (i.e. the source node of the corresponding arc).
- Node baseNode(OutArcIt) const { return INVALID; }
-
- /// \brief The running node of the iterator.
- ///
- /// Returns the running node of the given outgoing arc iterator
- /// (i.e. the target node of the corresponding arc).
- Node runningNode(OutArcIt) const { return INVALID; }
-
- /// \brief The base node of the iterator.
- ///
- /// Returns the base node of the given incomming arc iterator
- /// (i.e. the target node of the corresponding arc).
- Node baseNode(InArcIt) const { return INVALID; }
-
- /// \brief The running node of the iterator.
- ///
- /// Returns the running node of the given incomming arc iterator
- /// (i.e. the source node of the corresponding arc).
- Node runningNode(InArcIt) const { return INVALID; }
+ /// \brief Base node of the iterator
+ ///
+ /// Returns the base node (the source in this case) of the iterator
+ Node baseNode(OutArcIt e) const {
+ return source(e);
+ }
+ /// \brief Running node of the iterator
+ ///
+ /// Returns the running node (the target in this case) of the
+ /// iterator
+ Node runningNode(OutArcIt e) const {
+ return target(e);
+ }
+
+ /// \brief Base node of the iterator
+ ///
+ /// Returns the base node (the target in this case) of the iterator
+ Node baseNode(InArcIt e) const {
+ return target(e);
+ }
+ /// \brief Running node of the iterator
+ ///
+ /// Returns the running node (the source in this case) of the
+ /// iterator
+ Node runningNode(InArcIt e) const {
+ return source(e);
+ }
+
+ /// \brief Base node of the iterator
+ ///
+ /// Returns the base node of the iterator
+ Node baseNode(IncEdgeIt) const {
+ return INVALID;
+ }
+
+ /// \brief Running node of the iterator
+ ///
+ /// Returns the running node of the iterator
+ Node runningNode(IncEdgeIt) const {
+ return INVALID;
+ }
template
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h (revision 734)
+++ lemon/concepts/graph_components.h (revision 666)
@@ -93,5 +93,5 @@
/// associative containers (e.g. \c std::map).
///
- /// \note This operator only has to define some strict ordering of
+ /// \note This operator only have to define some strict ordering of
/// the items; this order has nothing to do with the iteration
/// ordering of the items.
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h (revision 710)
+++ lemon/concepts/heap.h (revision 584)
@@ -17,11 +17,11 @@
*/
-#ifndef LEMON_CONCEPTS_HEAP_H
-#define LEMON_CONCEPTS_HEAP_H
-
///\ingroup concept
///\file
///\brief The concept of heaps.
+#ifndef LEMON_CONCEPTS_HEAP_H
+#define LEMON_CONCEPTS_HEAP_H
+
#include
#include
@@ -36,25 +36,19 @@
/// \brief The heap concept.
///
- /// This concept class describes the main interface of heaps.
- /// The various \ref heaps "heap structures" 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.
+ /// Concept class describing the main interface of heaps. A \e heap
+ /// is a data structure for storing items with specified values called
+ /// \e priorities in such a way that finding the item with minimum
+ /// priority is efficient. In a heap one can change the priority of an
+ /// item, add or erase an item, etc.
///
- /// Heaps are crucial in several algorithms, such as Dijkstra and Prim.
- /// Any class that conforms to this concept can be used easily in such
- /// algorithms.
- ///
- /// \tparam PR Type of the priorities of the items.
- /// \tparam IM A read-writable item map with \c int values, used
+ /// \tparam PR Type of the priority of the items.
+ /// \tparam IM A read and writable item map with int values, used
/// internally to handle the cross references.
- /// \tparam CMP A functor class for comparing the priorities.
+ /// \tparam Comp A functor class for the ordering of the priorities.
/// The default is \c std::less.
#ifdef DOXYGEN
- template
+ template >
#else
- template >
+ template
#endif
class Heap {
@@ -71,6 +65,7 @@
///
/// Each item has a state associated to it. It can be "in heap",
- /// "pre-heap" or "post-heap". The latter two are indifferent from the
- /// heap's point of view, but may be useful to the user.
+ /// "pre heap" or "post heap". The later two are indifferent
+ /// from the point of view of the heap, but may be useful for
+ /// the user.
///
/// The item-int map must be initialized in such way that it assigns
@@ -78,58 +73,42 @@
enum State {
IN_HEAP = 0, ///< = 0. The "in heap" state constant.
- PRE_HEAP = -1, ///< = -1. The "pre-heap" state constant.
- POST_HEAP = -2 ///< = -2. The "post-heap" state constant.
+ PRE_HEAP = -1, ///< = -1. The "pre heap" state constant.
+ POST_HEAP = -2 ///< = -2. The "post heap" state constant.
};
- /// \brief Constructor.
- ///
- /// Constructor.
+ /// \brief The constructor.
+ ///
+ /// The constructor.
/// \param map A map that assigns \c int values to keys of type
/// \c Item. It is used internally by the heap implementations to
/// handle the cross references. The assigned value must be
- /// \c PRE_HEAP (-1) for each item.
+ /// \c PRE_HEAP (-1) for every item.
explicit Heap(ItemIntMap &map) {}
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to keys of type
- /// \c Item. It is used internally by the heap implementations to
- /// handle the cross references. The assigned value must be
- /// \c PRE_HEAP (-1) for each item.
- /// \param comp The function object used for comparing the priorities.
- explicit Heap(ItemIntMap &map, const CMP &comp) {}
-
/// \brief The number of items stored in the heap.
///
- /// This function returns the number of items stored in the heap.
+ /// Returns the number of items stored in the heap.
int size() const { return 0; }
- /// \brief Check if the heap is empty.
- ///
- /// This function returns \c true if the heap is empty.
+ /// \brief Checks if the heap is empty.
+ ///
+ /// Returns \c true if the heap is empty.
bool empty() const { return false; }
- /// \brief Make the heap empty.
- ///
- /// This functon makes the heap empty.
- /// It does not change the cross reference map. If you want to reuse
- /// a heap that is not surely empty, you should first clear it and
- /// then you should set the cross reference map to \c PRE_HEAP
- /// for each item.
- void clear() {}
-
- /// \brief Insert an item into the heap with the given priority.
- ///
- /// This function inserts the given item into the heap with the
- /// given priority.
+ /// \brief Makes the heap empty.
+ ///
+ /// Makes the heap empty.
+ void clear();
+
+ /// \brief Inserts an item into the heap with the given priority.
+ ///
+ /// Inserts the given item into the heap with the given priority.
/// \param i The item to insert.
/// \param p The priority of the item.
- /// \pre \e i must not be stored in the heap.
void push(const Item &i, const Prio &p) {}
- /// \brief Return the item having minimum priority.
- ///
- /// This function returns the item having minimum priority.
+ /// \brief Returns the item having minimum priority.
+ ///
+ /// Returns the item having minimum priority.
/// \pre The heap must be non-empty.
Item top() const {}
@@ -137,35 +116,33 @@
/// \brief The minimum priority.
///
- /// This function returns the minimum priority.
+ /// Returns the minimum priority.
/// \pre The heap must be non-empty.
Prio prio() const {}
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
+ /// \brief Removes the item having minimum priority.
+ ///
+ /// Removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {}
- /// \brief Remove the given item from the heap.
- ///
- /// This function removes the given item from the heap if it is
- /// already stored.
+ /// \brief Removes an item from the heap.
+ ///
+ /// Removes the given item from the heap if it is already stored.
/// \param i The item to delete.
- /// \pre \e i must be in the heap.
void erase(const Item &i) {}
- /// \brief The priority of the given item.
- ///
- /// This function returns the priority of the given item.
- /// \param i The item.
- /// \pre \e i must be in the heap.
+ /// \brief The priority of an item.
+ ///
+ /// Returns the priority of the given item.
+ /// \param i The item.
+ /// \pre \c i must be in the heap.
Prio operator[](const Item &i) const {}
- /// \brief Set the priority of an item or insert it, if it is
+ /// \brief Sets the priority of an item or inserts it, if it is
/// not stored in the heap.
///
/// This method sets the priority of the given item if it is
- /// already stored in the heap. Otherwise it inserts the given
- /// item into the heap with the given priority.
+ /// already stored in the heap.
+ /// Otherwise it inserts the given item with the given priority.
///
/// \param i The item.
@@ -173,21 +150,22 @@
void set(const Item &i, const Prio &p) {}
- /// \brief Decrease the priority of an item to the given value.
- ///
- /// This function decreases the priority of an item to the given value.
+ /// \brief Decreases the priority of an item to the given value.
+ ///
+ /// Decreases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
- /// \pre \e i must be stored in the heap with priority at least \e p.
+ /// \pre \c i must be stored in the heap with priority at least \c p.
void decrease(const Item &i, const Prio &p) {}
- /// \brief Increase the priority of an item to the given value.
- ///
- /// This function increases the priority of an item to the given value.
+ /// \brief Increases the priority of an item to the given value.
+ ///
+ /// Increases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
- /// \pre \e i must be stored in the heap with priority at most \e p.
+ /// \pre \c i must be stored in the heap with priority at most \c p.
void increase(const Item &i, const Prio &p) {}
- /// \brief Return the state of an item.
+ /// \brief Returns if an item is in, has already been in, or has
+ /// never been in the heap.
///
/// This method returns \c PRE_HEAP if the given item has never
@@ -199,9 +177,9 @@
State state(const Item &i) const {}
- /// \brief Set the state of an item in the heap.
- ///
- /// This function sets the state of the given item in the heap.
- /// It can be used to manually clear the heap when it is important
- /// to achive better time complexity.
+ /// \brief Sets the state of an item in the heap.
+ ///
+ /// Sets the state of the given item in the heap. It can be used
+ /// to manually clear the heap when it is important to achive the
+ /// better time complexity.
/// \param i The item.
/// \param st The state. It should not be \c IN_HEAP.
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h (revision 718)
+++ lemon/concepts/maps.h (revision 529)
@@ -183,6 +183,5 @@
template
struct Constraints {
- typename enable_if::type
- constraints() {
+ void constraints() {
checkConcept, _ReferenceMap >();
ref = m[key];
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc (revision 746)
+++ lemon/cplex.cc (revision 576)
@@ -112,37 +112,4 @@
}
- int CplexBase::_addRow(Value lb, ExprIterator b,
- ExprIterator e, Value ub) {
- int i = CPXgetnumrows(cplexEnv(), _prob);
- if (lb == -INF) {
- const char s = 'L';
- CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
- } else if (ub == INF) {
- const char s = 'G';
- CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
- } else if (lb == ub){
- const char s = 'E';
- CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
- } else {
- const char s = 'R';
- double len = ub - lb;
- CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
- }
-
- std::vector indices;
- std::vector rowlist;
- std::vector values;
-
- for(ExprIterator it=b; it!=e; ++it) {
- indices.push_back(it->first);
- values.push_back(it->second);
- rowlist.push_back(i);
- }
-
- CPXchgcoeflist(cplexEnv(), _prob, values.size(),
- &rowlist.front(), &indices.front(), &values.front());
-
- return i;
- }
void CplexBase::_eraseCol(int i) {
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h (revision 746)
+++ lemon/cplex.h (revision 576)
@@ -94,5 +94,4 @@
virtual int _addCol();
virtual int _addRow();
- virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h (revision 717)
+++ lemon/dfs.h (revision 584)
@@ -48,5 +48,5 @@
///The type of the map that stores the predecessor
///arcs of the %DFS paths.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap PredMap;
///Instantiates a \c PredMap.
@@ -63,6 +63,5 @@
///The type of the map that indicates which nodes are processed.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
- ///By default it is a NullMap.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef NullMap ProcessedMap;
///Instantiates a \c ProcessedMap.
@@ -83,5 +82,5 @@
///The type of the map that indicates which nodes are reached.
- ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap ReachedMap;
///Instantiates a \c ReachedMap.
@@ -98,5 +97,5 @@
///The type of the map that stores the distances of the nodes.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap DistMap;
///Instantiates a \c DistMap.
@@ -226,5 +225,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c PredMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetPredMap : public Dfs > {
@@ -246,5 +245,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c DistMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetDistMap : public Dfs< Digraph, SetDistMapTraits > {
@@ -266,5 +265,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c ReachedMap type.
- ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
template
struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits > {
@@ -286,5 +285,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c ProcessedMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits > {
@@ -413,6 +412,6 @@
///The simplest way to execute the DFS algorithm is to use one of the
///member functions called \ref run(Node) "run()".\n
- ///If you need better control on the execution, you have to call
- ///\ref init() first, then you can add a source node with \ref addSource()
+ ///If you need more control on the execution, first you have to call
+ ///\ref init(), then you can add a source node with \ref addSource()
///and perform the actual computation with \ref start().
///This procedure can be repeated if there are nodes that have not
@@ -671,7 +670,7 @@
///@{
- ///The DFS path to the given node.
-
- ///Returns the DFS path to the given node from the root(s).
+ ///The DFS path to a node.
+
+ ///Returns the DFS path to a node.
///
///\warning \c t should be reached from the root(s).
@@ -681,7 +680,7 @@
Path path(Node t) const { return Path(*G, *_pred, t); }
- ///The distance of the given node from the root(s).
-
- ///Returns the distance of the given node from the root(s).
+ ///The distance of a node from the root(s).
+
+ ///Returns the distance of a node from the root(s).
///
///\warning If node \c v is not reached from the root(s), then
@@ -692,5 +691,5 @@
int dist(Node v) const { return (*_dist)[v]; }
- ///Returns the 'previous arc' of the %DFS tree for the given node.
+ ///Returns the 'previous arc' of the %DFS tree for a node.
///This function returns the 'previous arc' of the %DFS tree for the
@@ -700,5 +699,5 @@
///
///The %DFS tree used here is equal to the %DFS tree used in
- ///\ref predNode() and \ref predMap().
+ ///\ref predNode().
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -706,13 +705,13 @@
Arc predArc(Node v) const { return (*_pred)[v];}
- ///Returns the 'previous node' of the %DFS tree for the given node.
+ ///Returns the 'previous node' of the %DFS tree.
///This function returns the 'previous node' of the %DFS
///tree for the node \c v, i.e. it returns the last but one node
- ///of a %DFS path from a root to \c v. It is \c INVALID
+ ///from a %DFS path from a root to \c v. It is \c INVALID
///if \c v is not reached from the root(s) or if \c v is a root.
///
///The %DFS tree used here is equal to the %DFS tree used in
- ///\ref predArc() and \ref predMap().
+ ///\ref predArc().
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -735,5 +734,5 @@
///
///Returns a const reference to the node map that stores the predecessor
- ///arcs, which form the DFS tree (forest).
+ ///arcs, which form the DFS tree.
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -741,5 +740,5 @@
const PredMap &predMap() const { return *_pred;}
- ///Checks if the given node. node is reached from the root(s).
+ ///Checks if a node is reached from the root(s).
///Returns \c true if \c v is reached from the root(s).
@@ -767,5 +766,5 @@
///The type of the map that stores the predecessor
///arcs of the %DFS paths.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap PredMap;
///Instantiates a PredMap.
@@ -782,5 +781,5 @@
///The type of the map that indicates which nodes are processed.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap ProcessedMap;
@@ -802,5 +801,5 @@
///The type of the map that indicates which nodes are reached.
- ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap ReachedMap;
///Instantiates a ReachedMap.
@@ -817,5 +816,5 @@
///The type of the map that stores the distances of the nodes.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap DistMap;
///Instantiates a DistMap.
@@ -832,5 +831,5 @@
///The type of the DFS paths.
- ///It must conform to the \ref concepts::Path "Path" concept.
+ ///It must meet the \ref concepts::Path "Path" concept.
typedef lemon::Path Path;
};
@@ -838,6 +837,10 @@
/// Default traits class used by DfsWizard
- /// Default traits class used by DfsWizard.
- /// \tparam GR The type of the digraph.
+ /// To make it easier to use Dfs algorithm
+ /// we have created a wizard class.
+ /// This \ref DfsWizard class needs default traits,
+ /// as well as the \ref Dfs class.
+ /// The \ref DfsWizardBase is a class to be the default traits of the
+ /// \ref DfsWizard class.
template
class DfsWizardBase : public DfsWizardDefaultTraits
@@ -867,5 +870,5 @@
/// Constructor.
- /// This constructor does not require parameters, it initiates
+ /// This constructor does not require parameters, therefore it initiates
/// all of the attributes to \c 0.
DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -897,4 +900,5 @@
typedef TR Base;
+ ///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
@@ -904,8 +908,14 @@
typedef typename Digraph::OutArcIt OutArcIt;
+ ///\brief The type of the map that stores the predecessor
+ ///arcs of the DFS paths.
typedef typename TR::PredMap PredMap;
+ ///\brief The type of the map that stores the distances of the nodes.
typedef typename TR::DistMap DistMap;
+ ///\brief The type of the map that indicates which nodes are reached.
typedef typename TR::ReachedMap ReachedMap;
+ ///\brief The type of the map that indicates which nodes are processed.
typedef typename TR::ProcessedMap ProcessedMap;
+ ///The type of the DFS paths
typedef typename TR::Path Path;
@@ -990,10 +1000,9 @@
SetPredMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the predecessor map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that stores the predecessor arcs of the nodes.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting PredMap object.
+ ///
+ ///\ref named-func-param "Named parameter"
+ ///for setting PredMap object.
template
DfsWizard > predMap(const T &t)
@@ -1009,10 +1018,9 @@
SetReachedMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the reached map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that indicates which nodes are reached.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting ReachedMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting ReachedMap object.
template
DfsWizard > reachedMap(const T &t)
@@ -1028,11 +1036,9 @@
SetDistMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the distance map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that stores the distances of the nodes calculated
- ///by the algorithm.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting DistMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting DistMap object.
template
DfsWizard > distMap(const T &t)
@@ -1048,10 +1054,9 @@
SetProcessedMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-func-param "Named parameter" for setting
- ///the processed map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that indicates which nodes are processed.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting ProcessedMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting ProcessedMap object.
template
DfsWizard > processedMap(const T &t)
@@ -1204,5 +1209,5 @@
///
/// The type of the map that indicates which nodes are reached.
- /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap ReachedMap;
@@ -1365,6 +1370,6 @@
/// The simplest way to execute the DFS algorithm is to use one of the
/// member functions called \ref run(Node) "run()".\n
- /// If you need better control on the execution, you have to call
- /// \ref init() first, then you can add a source node with \ref addSource()
+ /// If you need more control on the execution, first you have to call
+ /// \ref init(), then you can add a source node with \ref addSource()
/// and perform the actual computation with \ref start().
/// This procedure can be repeated if there are nodes that have not
@@ -1616,5 +1621,5 @@
///@{
- /// \brief Checks if the given node is reached from the root(s).
+ /// \brief Checks if a node is reached from the root(s).
///
/// Returns \c true if \c v is reached from the root(s).
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h (revision 717)
+++ lemon/dijkstra.h (revision 584)
@@ -71,7 +71,7 @@
///The type of the map that stores the arc lengths.
- ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+ ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
typedef LEN LengthMap;
- ///The type of the arc lengths.
+ ///The type of the length of the arcs.
typedef typename LEN::Value Value;
@@ -117,5 +117,5 @@
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap PredMap;
///Instantiates a \c PredMap.
@@ -132,5 +132,5 @@
///The type of the map that indicates which nodes are processed.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap ProcessedMap;
@@ -152,5 +152,5 @@
///The type of the map that stores the distances of the nodes.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap DistMap;
///Instantiates a \c DistMap.
@@ -169,8 +169,4 @@
/// \ingroup shortest_path
///This class provides an efficient implementation of the %Dijkstra algorithm.
- ///
- ///The %Dijkstra algorithm solves the single-source shortest path problem
- ///when all arc lengths are non-negative. If there are negative lengths,
- ///the BellmanFord algorithm should be used instead.
///
///The arc lengths are passed to the algorithm using a
@@ -206,5 +202,5 @@
typedef typename TR::Digraph Digraph;
- ///The type of the arc lengths.
+ ///The type of the length of the arcs.
typedef typename TR::LengthMap::Value Value;
///The type of the map that stores the arc lengths.
@@ -309,5 +305,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c PredMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetPredMap
@@ -330,5 +326,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c DistMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetDistMap
@@ -351,5 +347,5 @@
///\ref named-templ-param "Named parameter" for setting
///\c ProcessedMap type.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
template
struct SetProcessedMap
@@ -448,5 +444,4 @@
///\ref named-templ-param "Named parameter" for setting
///\c OperationTraits type.
- /// For more information see \ref DijkstraDefaultOperationTraits.
template
struct SetOperationTraits
@@ -590,6 +585,6 @@
///The simplest way to execute the %Dijkstra algorithm is to use
///one of the member functions called \ref run(Node) "run()".\n
- ///If you need better control on the execution, you have to call
- ///\ref init() first, then you can add several source nodes with
+ ///If you need more control on the execution, first you have to call
+ ///\ref init(), then you can add several source nodes with
///\ref addSource(). Finally the actual path computation can be
///performed with one of the \ref start() functions.
@@ -807,12 +802,12 @@
///The results of the %Dijkstra algorithm can be obtained using these
///functions.\n
- ///Either \ref run(Node) "run()" or \ref init() should be called
+ ///Either \ref run(Node) "run()" or \ref start() should be called
///before using them.
///@{
- ///The shortest path to the given node.
-
- ///Returns the shortest path to the given node from the root(s).
+ ///The shortest path to a node.
+
+ ///Returns the shortest path to a node.
///
///\warning \c t should be reached from the root(s).
@@ -822,7 +817,7 @@
Path path(Node t) const { return Path(*G, *_pred, t); }
- ///The distance of the given node from the root(s).
-
- ///Returns the distance of the given node from the root(s).
+ ///The distance of a node from the root(s).
+
+ ///Returns the distance of a node from the root(s).
///
///\warning If node \c v is not reached from the root(s), then
@@ -833,7 +828,6 @@
Value dist(Node v) const { return (*_dist)[v]; }
- ///\brief Returns the 'previous arc' of the shortest path tree for
- ///the given node.
- ///
+ ///Returns the 'previous arc' of the shortest path tree for a node.
+
///This function returns the 'previous arc' of the shortest path
///tree for the node \c v, i.e. it returns the last arc of a
@@ -842,5 +836,5 @@
///
///The shortest path tree used here is equal to the shortest path
- ///tree used in \ref predNode() and \ref predMap().
+ ///tree used in \ref predNode().
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -848,14 +842,13 @@
Arc predArc(Node v) const { return (*_pred)[v]; }
- ///\brief Returns the 'previous node' of the shortest path tree for
- ///the given node.
- ///
+ ///Returns the 'previous node' of the shortest path tree for a node.
+
///This function returns the 'previous node' of the shortest path
///tree for the node \c v, i.e. it returns the last but one node
- ///of a shortest path from a root to \c v. It is \c INVALID
+ ///from a shortest path from a root to \c v. It is \c INVALID
///if \c v is not reached from the root(s) or if \c v is a root.
///
///The shortest path tree used here is equal to the shortest path
- ///tree used in \ref predArc() and \ref predMap().
+ ///tree used in \ref predArc().
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -878,5 +871,5 @@
///
///Returns a const reference to the node map that stores the predecessor
- ///arcs, which form the shortest path tree (forest).
+ ///arcs, which form the shortest path tree.
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -884,5 +877,5 @@
const PredMap &predMap() const { return *_pred;}
- ///Checks if the given node is reached from the root(s).
+ ///Checks if a node is reached from the root(s).
///Returns \c true if \c v is reached from the root(s).
@@ -903,7 +896,7 @@
Heap::POST_HEAP; }
- ///The current distance of the given node from the root(s).
-
- ///Returns the current distance of the given node from the root(s).
+ ///The current distance of a node from the root(s).
+
+ ///Returns the current distance of a node from the root(s).
///It may be decreased in the following processes.
///
@@ -932,7 +925,7 @@
///The type of the map that stores the arc lengths.
- ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+ ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
typedef LEN LengthMap;
- ///The type of the arc lengths.
+ ///The type of the length of the arcs.
typedef typename LEN::Value Value;
@@ -981,5 +974,5 @@
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap PredMap;
///Instantiates a PredMap.
@@ -996,5 +989,5 @@
///The type of the map that indicates which nodes are processed.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap ProcessedMap;
@@ -1016,5 +1009,5 @@
///The type of the map that stores the distances of the nodes.
- ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap DistMap;
///Instantiates a DistMap.
@@ -1031,5 +1024,5 @@
///The type of the shortest paths.
- ///It must conform to the \ref concepts::Path "Path" concept.
+ ///It must meet the \ref concepts::Path "Path" concept.
typedef lemon::Path Path;
};
@@ -1037,7 +1030,10 @@
/// Default traits class used by DijkstraWizard
- /// Default traits class used by DijkstraWizard.
- /// \tparam GR The type of the digraph.
- /// \tparam LEN The type of the length map.
+ /// To make it easier to use Dijkstra algorithm
+ /// we have created a wizard class.
+ /// This \ref DijkstraWizard class needs default traits,
+ /// as well as the \ref Dijkstra class.
+ /// The \ref DijkstraWizardBase is a class to be the default traits of the
+ /// \ref DijkstraWizard class.
template
class DijkstraWizardBase : public DijkstraWizardDefaultTraits
@@ -1098,4 +1094,5 @@
typedef TR Base;
+ ///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
@@ -1105,10 +1102,18 @@
typedef typename Digraph::OutArcIt OutArcIt;
+ ///The type of the map that stores the arc lengths.
typedef typename TR::LengthMap LengthMap;
+ ///The type of the length of the arcs.
typedef typename LengthMap::Value Value;
+ ///\brief The type of the map that stores the predecessor
+ ///arcs of the shortest paths.
typedef typename TR::PredMap PredMap;
+ ///The type of the map that stores the distances of the nodes.
typedef typename TR::DistMap DistMap;
+ ///The type of the map that indicates which nodes are processed.
typedef typename TR::ProcessedMap ProcessedMap;
+ ///The type of the shortest paths
typedef typename TR::Path Path;
+ ///The heap type used by the dijkstra algorithm.
typedef typename TR::Heap Heap;
@@ -1182,10 +1187,9 @@
SetPredMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the predecessor map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that stores the predecessor arcs of the nodes.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting PredMap object.
+ ///
+ ///\ref named-func-param "Named parameter"
+ ///for setting PredMap object.
template
DijkstraWizard > predMap(const T &t)
@@ -1201,11 +1205,9 @@
SetDistMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-templ-param "Named parameter" for setting
- ///the distance map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that stores the distances of the nodes calculated
- ///by the algorithm.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting DistMap object.
+ ///
+ ///\ref named-func-param "Named parameter"
+ ///for setting DistMap object.
template
DijkstraWizard > distMap(const T &t)
@@ -1221,10 +1223,9 @@
SetProcessedMapBase(const TR &b) : TR(b) {}
};
-
- ///\brief \ref named-func-param "Named parameter" for setting
- ///the processed map.
- ///
- ///\ref named-templ-param "Named parameter" function for setting
- ///the map that indicates which nodes are processed.
+ ///\brief \ref named-func-param "Named parameter"
+ ///for setting ProcessedMap object.
+ ///
+ /// \ref named-func-param "Named parameter"
+ ///for setting ProcessedMap object.
template
DijkstraWizard > processedMap(const T &t)
@@ -1239,5 +1240,4 @@
SetPathBase(const TR &b) : TR(b) {}
};
-
///\brief \ref named-func-param "Named parameter"
///for getting the shortest path to the target node.
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h (revision 714)
+++ lemon/dim2.h (revision 440)
@@ -22,7 +22,14 @@
#include
-///\ingroup geomdat
+///\ingroup misc
///\file
///\brief A simple two dimensional vector and a bounding box implementation
+///
+/// The class \ref lemon::dim2::Point "dim2::Point" implements
+/// a two dimensional vector with the usual operations.
+///
+/// The class \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.
namespace lemon {
@@ -34,5 +41,5 @@
namespace dim2 {
- /// \addtogroup geomdat
+ /// \addtogroup misc
/// @{
Index: mon/fib_heap.h
===================================================================
--- lemon/fib_heap.h (revision 711)
+++ (revision )
@@ -1,475 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_FIB_HEAP_H
-#define LEMON_FIB_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
-
-#include
-#include
-#include
-#include
-
-namespace lemon {
-
- /// \ingroup heaps
- ///
- /// \brief Fibonacci heap data structure.
- ///
- /// This class implements the \e Fibonacci \e heap data structure.
- /// It fully conforms to the \ref concepts::Heap "heap concept".
- ///
- /// The methods \ref increase() and \ref erase() are not efficient in a
- /// Fibonacci heap. In case of many calls of these operations, it is
- /// better to use other heap structure, e.g. \ref BinHeap "binary heap".
- ///
- /// \tparam PR Type of the priorities of the items.
- /// \tparam IM A read-writable item map with \c int values, used
- /// internally to handle the cross references.
- /// \tparam CMP A functor class for comparing the priorities.
- /// The default is \c std::less.
-#ifdef DOXYGEN
- template
-#else
- template >
-#endif
- class FibHeap {
- public:
-
- /// Type of the item-int map.
- typedef IM ItemIntMap;
- /// Type of the priorities.
- typedef PR Prio;
- /// Type of the items stored in the heap.
- typedef typename ItemIntMap::Key Item;
- /// Type of the item-priority pairs.
- typedef std::pair
- Pair;
- /// Functor type for comparing the priorities.
- typedef CMP Compare;
-
- private:
- class Store;
-
- std::vector _data;
- int _minimum;
- ItemIntMap &_iim;
- Compare _comp;
- int _num;
-
- public:
-
- /// \brief Type to represent the states of the items.
- ///
- /// Each item has a state associated to it. It can be "in heap",
- /// "pre-heap" or "post-heap". The latter two are indifferent from the
- /// heap's point of view, but may be useful to the user.
- ///
- /// The item-int map must be initialized in such way that it assigns
- /// \c PRE_HEAP (-1) to any element to be put in the heap.
- enum State {
- IN_HEAP = 0, ///< = 0.
- PRE_HEAP = -1, ///< = -1.
- POST_HEAP = -2 ///< = -2.
- };
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- explicit FibHeap(ItemIntMap &map)
- : _minimum(0), _iim(map), _num() {}
-
- /// \brief Constructor.
- ///
- /// Constructor.
- /// \param map A map that assigns \c int values to the items.
- /// It is used internally to handle the cross references.
- /// The assigned value must be \c PRE_HEAP (-1) for each item.
- /// \param comp The function object used for comparing the priorities.
- FibHeap(ItemIntMap &map, const Compare &comp)
- : _minimum(0), _iim(map), _comp(comp), _num() {}
-
- /// \brief The number of items stored in the heap.
- ///
- /// This function returns the number of items stored in the heap.
- int size() const { return _num; }
-
- /// \brief Check if the heap is empty.
- ///
- /// This function returns \c true if the heap is empty.
- bool empty() const { return _num==0; }
-
- /// \brief Make the heap empty.
- ///
- /// This functon makes the heap empty.
- /// It does not change the cross reference map. If you want to reuse
- /// a heap that is not surely empty, you should first clear it and
- /// then you should set the cross reference map to \c PRE_HEAP
- /// for each item.
- void clear() {
- _data.clear(); _minimum = 0; _num = 0;
- }
-
- /// \brief Insert an item into the heap with the given priority.
- ///
- /// This function inserts the given item into the heap with the
- /// given priority.
- /// \param item The item to insert.
- /// \param prio The priority of the item.
- /// \pre \e item must not be stored in the heap.
- void push (const Item& item, const Prio& prio) {
- int i=_iim[item];
- if ( i < 0 ) {
- int s=_data.size();
- _iim.set( item, s );
- Store st;
- st.name=item;
- _data.push_back(st);
- i=s;
- } else {
- _data[i].parent=_data[i].child=-1;
- _data[i].degree=0;
- _data[i].in=true;
- _data[i].marked=false;
- }
-
- if ( _num ) {
- _data[_data[_minimum].right_neighbor].left_neighbor=i;
- _data[i].right_neighbor=_data[_minimum].right_neighbor;
- _data[_minimum].right_neighbor=i;
- _data[i].left_neighbor=_minimum;
- if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
- } else {
- _data[i].right_neighbor=_data[i].left_neighbor=i;
- _minimum=i;
- }
- _data[i].prio=prio;
- ++_num;
- }
-
- /// \brief Return the item having minimum priority.
- ///
- /// This function returns the item having minimum priority.
- /// \pre The heap must be non-empty.
- Item top() const { return _data[_minimum].name; }
-
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
- Prio prio() const { return _data[_minimum].prio; }
-
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
- /// \pre The heap must be non-empty.
- void pop() {
- /*The first case is that there are only one root.*/
- if ( _data[_minimum].left_neighbor==_minimum ) {
- _data[_minimum].in=false;
- if ( _data[_minimum].degree!=0 ) {
- makeRoot(_data[_minimum].child);
- _minimum=_data[_minimum].child;
- balance();
- }
- } else {
- int right=_data[_minimum].right_neighbor;
- unlace(_minimum);
- _data[_minimum].in=false;
- if ( _data[_minimum].degree > 0 ) {
- int left=_data[_minimum].left_neighbor;
- int child=_data[_minimum].child;
- int last_child=_data[child].left_neighbor;
-
- makeRoot(child);
-
- _data[left].right_neighbor=child;
- _data[child].left_neighbor=left;
- _data[right].left_neighbor=last_child;
- _data[last_child].right_neighbor=right;
- }
- _minimum=right;
- balance();
- } // the case where there are more roots
- --_num;
- }
-
- /// \brief Remove the given item from the heap.
- ///
- /// This function removes the given item from the heap if it is
- /// already stored.
- /// \param item The item to delete.
- /// \pre \e item must be in the heap.
- void erase (const Item& item) {
- int i=_iim[item];
-
- if ( i >= 0 && _data[i].in ) {
- if ( _data[i].parent!=-1 ) {
- int p=_data[i].parent;
- cut(i,p);
- cascade(p);
- }
- _minimum=i; //As if its prio would be -infinity
- pop();
- }
- }
-
- /// \brief The priority of the given item.
- ///
- /// This function returns the priority of the given item.
- /// \param item The item.
- /// \pre \e item must be in the heap.
- Prio operator[](const Item& item) const {
- return _data[_iim[item]].prio;
- }
-
- /// \brief Set the priority of an item or insert it, if it is
- /// not stored in the heap.
- ///
- /// This method sets the priority of the given item if it is
- /// already stored in the heap. Otherwise it inserts the given
- /// item into the heap with the given priority.
- /// \param item The item.
- /// \param prio The priority.
- void set (const Item& item, const Prio& prio) {
- int i=_iim[item];
- if ( i >= 0 && _data[i].in ) {
- if ( _comp(prio, _data[i].prio) ) decrease(item, prio);
- if ( _comp(_data[i].prio, prio) ) increase(item, prio);
- } else push(item, prio);
- }
-
- /// \brief Decrease the priority of an item to the given value.
- ///
- /// This function decreases the priority of an item to the given value.
- /// \param item The item.
- /// \param prio The priority.
- /// \pre \e item must be stored in the heap with priority at least \e prio.
- void decrease (const Item& item, const Prio& prio) {
- int i=_iim[item];
- _data[i].prio=prio;
- int p=_data[i].parent;
-
- if ( p!=-1 && _comp(prio, _data[p].prio) ) {
- cut(i,p);
- cascade(p);
- }
- if ( _comp(prio, _data[_minimum].prio) ) _minimum=i;
- }
-
- /// \brief Increase the priority of an item to the given value.
- ///
- /// This function increases the priority of an item to the given value.
- /// \param item The item.
- /// \param prio The priority.
- /// \pre \e item must be stored in the heap with priority at most \e prio.
- void increase (const Item& item, const Prio& prio) {
- erase(item);
- push(item, prio);
- }
-
- /// \brief Return the state of an item.
- ///
- /// This method returns \c PRE_HEAP if the given item has never
- /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
- /// and \c POST_HEAP otherwise.
- /// In the latter case it is possible that the item will get back
- /// to the heap again.
- /// \param item The item.
- State state(const Item &item) const {
- int i=_iim[item];
- if( i>=0 ) {
- if ( _data[i].in ) i=0;
- else i=-2;
- }
- return State(i);
- }
-
- /// \brief Set the state of an item in the heap.
- ///
- /// This function sets the state of the given item in the heap.
- /// It can be used to manually clear the heap when it is important
- /// to achive better time complexity.
- /// \param i The item.
- /// \param st The state. It should not be \c IN_HEAP.
- void state(const Item& i, State st) {
- switch (st) {
- case POST_HEAP:
- case PRE_HEAP:
- if (state(i) == IN_HEAP) {
- erase(i);
- }
- _iim[i] = st;
- break;
- case IN_HEAP:
- break;
- }
- }
-
- private:
-
- void balance() {
-
- int maxdeg=int( std::floor( 2.08*log(double(_data.size()))))+1;
-
- std::vector A(maxdeg,-1);
-
- /*
- *Recall that now minimum does not point to the minimum prio element.
- *We set minimum to this during balance().
- */
- int anchor=_data[_minimum].left_neighbor;
- int next=_minimum;
- bool end=false;
-
- do {
- int active=next;
- if ( anchor==active ) end=true;
- int d=_data[active].degree;
- next=_data[active].right_neighbor;
-
- while (A[d]!=-1) {
- if( _comp(_data[active].prio, _data[A[d]].prio) ) {
- fuse(active,A[d]);
- } else {
- fuse(A[d],active);
- active=A[d];
- }
- A[d]=-1;
- ++d;
- }
- A[d]=active;
- } while ( !end );
-
-
- while ( _data[_minimum].parent >=0 )
- _minimum=_data[_minimum].parent;
- int s=_minimum;
- int m=_minimum;
- do {
- if ( _comp(_data[s].prio, _data[_minimum].prio) ) _minimum=s;
- s=_data[s].right_neighbor;
- } while ( s != m );
- }
-
- void makeRoot(int c) {
- int s=c;
- do {
- _data[s].parent=-1;
- s=_data[s].right_neighbor;
- } while ( s != c );
- }
-
- void cut(int a, int b) {
- /*
- *Replacing a from the children of b.
- */
- --_data[b].degree;
-
- if ( _data[b].degree !=0 ) {
- int child=_data[b].child;
- if ( child==a )
- _data[b].child=_data[child].right_neighbor;
- unlace(a);
- }
-
-
- /*Lacing a to the roots.*/
- int right=_data[_minimum].right_neighbor;
- _data[_minimum].right_neighbor=a;
- _data[a].left_neighbor=_minimum;
- _data[a].right_neighbor=right;
- _data[right].left_neighbor=a;
-
- _data[a].parent=-1;
- _data[a].marked=false;
- }
-
- void cascade(int a) {
- if ( _data[a].parent!=-1 ) {
- int p=_data[a].parent;
-
- if ( _data[a].marked==false ) _data[a].marked=true;
- else {
- cut(a,p);
- cascade(p);
- }
- }
- }
-
- void fuse(int a, int b) {
- unlace(b);
-
- /*Lacing b under a.*/
- _data[b].parent=a;
-
- if (_data[a].degree==0) {
- _data[b].left_neighbor=b;
- _data[b].right_neighbor=b;
- _data[a].child=b;
- } else {
- int child=_data[a].child;
- int last_child=_data[child].left_neighbor;
- _data[child].left_neighbor=b;
- _data[b].right_neighbor=child;
- _data[last_child].right_neighbor=b;
- _data[b].left_neighbor=last_child;
- }
-
- ++_data[a].degree;
-
- _data[b].marked=false;
- }
-
- /*
- *It is invoked only if a has siblings.
- */
- void unlace(int a) {
- int leftn=_data[a].left_neighbor;
- int rightn=_data[a].right_neighbor;
- _data[leftn].right_neighbor=rightn;
- _data[rightn].left_neighbor=leftn;
- }
-
-
- class Store {
- friend class FibHeap;
-
- Item name;
- int parent;
- int left_neighbor;
- int right_neighbor;
- int child;
- int degree;
- bool marked;
- bool in;
- Prio prio;
-
- Store() : parent(-1), child(-1), degree(), marked(false), in(true) {}
- };
- };
-
-} //namespace lemon
-
-#endif //LEMON_FIB_HEAP_H
-
Index: mon/fourary_heap.h
===================================================================
--- lemon/fourary_heap.h (revision 706)
+++ (revision )
@@ -1,342 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_FOURARY_HEAP_H
-#define LEMON_FOURARY_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Fourary heap implementation.
-
-#include
-#include
-#include
-
-namespace lemon {
-
- /// \ingroup heaps
- ///
- ///\brief Fourary heap data structure.
- ///
- /// This class implements the \e fourary \e heap data structure.
- /// It fully conforms to the \ref concepts::Heap "heap concept".
- ///
- /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap"
- /// for K=4. It is similar to the \ref BinHeap "binary heap",
- /// but its nodes have at most four children, instead of two.
- ///
- /// \tparam PR Type of the priorities of the items.
- /// \tparam IM A read-writable item map with \c int values, used
- /// internally to handle the cross references.
- /// \tparam CMP A functor class for comparing the priorities.
- /// The default is \c std::less.
- ///
- ///\sa BinHeap
- ///\sa KaryHeap
-#ifdef DOXYGEN
- template
-#else
- template