Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt (revision 791)
+++ CMakeLists.txt (revision 727)
@@ -35,6 +35,4 @@
CHECK_TYPE_SIZE("long long" LONG_LONG)
SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
-
-INCLUDE(FindPythonInterp)
ENABLE_TESTING()
Index: Makefile.am
===================================================================
--- Makefile.am (revision 799)
+++ Makefile.am (revision 676)
@@ -18,5 +18,4 @@
cmake/FindGLPK.cmake \
cmake/FindCOIN.cmake \
- cmake/LEMONConfig.cmake.in \
cmake/version.cmake.in \
cmake/version.cmake \
Index: configure.ac
===================================================================
--- configure.ac (revision 791)
+++ configure.ac (revision 727)
@@ -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 791)
+++ doc/CMakeLists.txt (revision 726)
@@ -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 803)
+++ doc/Doxyfile.in (revision 379)
@@ -1,3 +1,3 @@
-# Doxyfile 1.5.9
+# Doxyfile 1.5.7.1
#---------------------------------------------------------------------------
@@ -22,4 +22,5 @@
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP = YES
INHERIT_DOCS = NO
SEPARATE_MEMBER_PAGES = NO
@@ -91,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 \
@@ -224,5 +224,5 @@
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
-# Options related to the search engine
+# Configuration::additions related to external references
#---------------------------------------------------------------------------
TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ "
Index: doc/Makefile.am
===================================================================
--- doc/Makefile.am (revision 791)
+++ doc/Makefile.am (revision 720)
@@ -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 818)
+++ doc/groups.dox (revision 710)
@@ -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
*/
@@ -281,26 +260,4 @@
/**
-@defgroup geomdat Geometric Data Structures
-@ingroup auxdat
-\brief Geometric data structures implemented in LEMON.
-
-This group contains geometric data structures implemented in LEMON.
-
- - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional
- vector with the usual operations.
- - \ref lemon::dim2::Box "dim2::Box" can be used to determine the
- rectangular bounding box of a set of \ref lemon::dim2::Point
- "dim2::Point"'s.
-*/
-
-/**
-@defgroup matrices Matrices
-@ingroup auxdat
-\brief Two dimensional data storages implemented in LEMON.
-
-This group contains two dimensional data storages implemented in LEMON.
-*/
-
-/**
@defgroup algs Algorithms
\brief This group contains the several algorithms
@@ -317,6 +274,5 @@
This group contains the common graph search algorithms, namely
-\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
-\ref clrs01algorithms.
+\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
*/
@@ -326,6 +282,5 @@
\brief Algorithms for finding shortest paths.
-This group contains the algorithms for finding shortest paths in digraphs
-\ref clrs01algorithms.
+This group contains the algorithms for finding shortest paths in digraphs.
- \ref Dijkstra algorithm for finding shortest paths from a source node
@@ -344,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 \ref clrs01algorithms.
-*/
-
-/**
@defgroup max_flow Maximum Flow Algorithms
@ingroup algs
@@ -358,5 +304,5 @@
This group contains the algorithms for finding maximum flows and
-feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
+feasible circulations.
The \e maximum \e flow \e problem is to find a flow of maximum value between
@@ -373,14 +319,10 @@
LEMON contains several algorithms for solving maximum flow problems:
-- \ref EdmondsKarp Edmonds-Karp algorithm
- \ref edmondskarp72theoretical.
-- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
- \ref goldberg88newapproach.
-- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
- \ref dinic70algorithm, \ref sleator83dynamic.
-- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
- \ref goldberg88newapproach, \ref sleator83dynamic.
-
-In most cases the \ref Preflow algorithm provides the
+- \ref EdmondsKarp Edmonds-Karp algorithm.
+- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.
+- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.
+- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.
+
+In most cases the \ref Preflow "Preflow" algorithm provides the
fastest method for computing a maximum flow. All implementations
also provide functions to query the minimum cut, which is the dual
@@ -400,20 +342,16 @@
This group contains the algorithms for finding minimum cost flows and
-circulations \ref amo93networkflows. For more information about this
-problem and its dual solution, see \ref min_cost_flow
-"Minimum Cost Flow Problem".
+circulations. For more information about this problem and its dual
+solution see \ref min_cost_flow "Minimum Cost Flow Problem".
LEMON contains several algorithms for this problem.
- \ref NetworkSimplex Primal Network Simplex algorithm with various
- pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
+ pivot strategies.
- \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
- cost scaling \ref goldberg90approximation, \ref goldberg97efficient,
- \ref bunnagel98efficient.
+ cost scaling.
- \ref CapacityScaling Successive Shortest %Path algorithm with optional
- capacity scaling \ref edmondskarp72theoretical.
- - \ref CancelAndTighten The Cancel and Tighten algorithm
- \ref goldberg89cyclecanceling.
- - \ref CycleCanceling Cycle-Canceling algorithms
- \ref klein67primal, \ref goldberg89cyclecanceling.
+ capacity scaling.
+ - \ref CancelAndTighten The Cancel and Tighten algorithm.
+ - \ref CycleCanceling Cycle-Canceling algorithms.
In general NetworkSimplex is the most efficient implementation,
@@ -438,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:
@@ -454,38 +392,25 @@
/**
-@defgroup min_mean_cycle Minimum Mean Cycle Algorithms
-@ingroup algs
-\brief Algorithms for finding minimum mean cycles.
-
-This group contains the algorithms for finding minimum mean cycles
-\ref clrs01algorithms, \ref amo93networkflows.
-
-The \e minimum \e mean \e cycle \e problem is to find a directed cycle
-of minimum mean length (cost) in a digraph.
-The mean length of a cycle is the average length of its arcs, i.e. the
-ratio between the total length of the cycle and the number of arcs on it.
-
-This problem has an important connection to \e conservative \e length
-\e functions, too. A length function on the arcs of a digraph is called
-conservative if and only if there is no directed cycle of negative total
-length. For an arbitrary length function, the negative of the minimum
-cycle mean is the smallest \f$\epsilon\f$ value so that increasing the
-arc lengths uniformly by \f$\epsilon\f$ results in a conservative length
-function.
-
-LEMON contains three algorithms for solving the minimum mean cycle problem:
-- \ref Karp "Karp"'s original algorithm \ref amo93networkflows,
- \ref dasdan98minmeancycle.
-- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved
- version of Karp's algorithm \ref dasdan98minmeancycle.
-- \ref Howard "Howard"'s policy iteration algorithm
- \ref dasdan98minmeancycle.
-
-In practice, the Howard algorithm proved to be by far the most efficient
-one, though the best known theoretical bound on its running time is
-exponential.
-Both Karp and HartmannOrlin algorithms run in time O(ne) and use space
-O(n2+e), but the latter one is typically faster due to the
-applied early termination scheme.
+@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
*/
@@ -531,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.
*/
@@ -561,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.
*/
@@ -582,14 +492,11 @@
/**
-@defgroup lp_group LP and MIP Solvers
+@defgroup lp_group Lp and Mip Solvers
@ingroup gen_opt_group
-\brief LP and MIP solver interfaces for LEMON.
-
-This group contains LP and MIP solver interfaces for LEMON.
-Various LP solvers could be used in the same manner with this
-high-level interface.
-
-The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
-\ref cplex, \ref soplex.
+\brief Lp and Mip solver interfaces for LEMON.
+
+This group contains Lp and Mip solver interfaces for LEMON. The
+various LP solvers could be used in the same manner with this
+interface.
*/
@@ -681,5 +588,5 @@
/**
-@defgroup dimacs_group DIMACS Format
+@defgroup dimacs_group DIMACS format
@ingroup io_group
\brief Read and write files in DIMACS format
@@ -730,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.
*/
@@ -743,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
@@ -751,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: doc/mainpage.dox
===================================================================
--- doc/mainpage.dox (revision 802)
+++ doc/mainpage.dox (revision 705)
@@ -22,9 +22,12 @@
\section intro Introduction
-LEMON stands for Library for Efficient Modeling
-and Optimization in Networks.
-It is a C++ template library providing efficient implementation of common
-data structures and algorithms with focus on combinatorial optimization
-problems in graphs and networks.
+\subsection whatis What is LEMON
+
+LEMON stands for Library for Efficient Modeling
+and Optimization in Networks.
+It is a C++ template
+library aimed at combinatorial optimization tasks which
+often involve in working
+with graphs.
@@ -36,14 +39,5 @@
-The project is maintained by the
-Egerváry Research Group on
-Combinatorial Optimization \ref egres
-at the Operations Research Department of the
-Eötvös Loránd University,
-Budapest, Hungary.
-LEMON is also a member of the COIN-OR
-initiative \ref coinor.
-
-\section howtoread How to Read the Documentation
+\subsection howtoread How to read the documentation
If you would like to get to know the library, see
Index: doc/min_cost_flow.dox
===================================================================
--- doc/min_cost_flow.dox (revision 802)
+++ doc/min_cost_flow.dox (revision 710)
@@ -27,5 +27,5 @@
minimum total cost from a set of supply nodes to a set of demand nodes
in a network with capacity constraints (lower and upper bounds)
-and arc costs \ref amo93networkflows.
+and arc costs.
Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
Index: c/references.bib
===================================================================
--- doc/references.bib (revision 802)
+++ (revision )
@@ -1,301 +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},
- url = {http://www.cs.elte.hu/egres/}
-}
-
-@misc{coinor,
- key = {COIN-OR},
- title = {{COIN-OR} -- {C}omputational {I}nfrastructure for
- {O}perations {R}esearch},
- url = {http://www.coin-or.org/}
-}
-
-
-%%%%% Other libraries %%%%%%
-
-@misc{boost,
- key = {Boost},
- title = {{B}oost {C++} {L}ibraries},
- url = {http://www.boost.org/}
-}
-
-@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},
- url = {http://www.algorithmic-solutions.com/}
-}
-
-@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},
- url = {http://www.cmake.org/}
-}
-
-@misc{doxygen,
- key = {Doxygen},
- title = {{Doxygen} -- {S}ource code documentation generator
- tool},
- url = {http://www.doxygen.org/}
-}
-
-
-%%%%% LP/MIP libraries %%%%%
-
-@misc{glpk,
- key = {GLPK},
- title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it},
- url = {http://www.gnu.org/software/glpk/}
-}
-
-@misc{clp,
- key = {Clp},
- title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming},
- url = {http://projects.coin-or.org/Clp/}
-}
-
-@misc{cbc,
- key = {Cbc},
- title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut},
- url = {http://projects.coin-or.org/Cbc/}
-}
-
-@misc{cplex,
- key = {CPLEX},
- title = {{ILOG} {CPLEX}},
- url = {http://www.ilog.com/}
-}
-
-@misc{soplex,
- key = {SoPlex},
- title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented
- {S}implex},
- url = {http://soplex.zib.de/}
-}
-
-
-%%%%% 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 %%%%%
-
-@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}
-}
-
-@article{goldberg88newapproach,
- author = {Andrew V. Goldberg and Robert E. Tarjan},
- title = {A new approach to the maximum flow problem},
- journal = {Journal of the ACM},
- year = 1988,
- volume = 35,
- number = 4,
- pages = {921-940}
-}
-
-@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}
-}
-
-@article{goldberg89cyclecanceling,
- author = {Andrew V. Goldberg and Robert E. Tarjan},
- title = {Finding minimum-cost circulations by canceling
- negative cycles},
- journal = {Journal of the ACM},
- year = 1989,
- volume = 36,
- number = 4,
- pages = {873-886}
-}
-
-@article{goldberg90approximation,
- 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}
-}
-
-@book{dantzig63linearprog,
- author = {George B. Dantzig},
- title = {Linear Programming and Extensions},
- publisher = {Princeton University Press},
- year = 1963
-}
-
-@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,
-}
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am (revision 817)
+++ lemon/Makefile.am (revision 820)
@@ -58,8 +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 \
@@ -81,5 +79,4 @@
lemon/euler.h \
lemon/fib_heap.h \
- lemon/fourary_heap.h \
lemon/full_graph.h \
lemon/glpk.h \
@@ -87,9 +84,5 @@
lemon/graph_to_eps.h \
lemon/grid_graph.h \
- lemon/hartmann_orlin.h \
- lemon/howard.h \
lemon/hypercube_graph.h \
- lemon/karp.h \
- lemon/kary_heap.h \
lemon/kruskal.h \
lemon/hao_orlin.h \
@@ -106,5 +99,4 @@
lemon/nauty_reader.h \
lemon/network_simplex.h \
- lemon/pairing_heap.h \
lemon/path.h \
lemon/preflow.h \
@@ -114,4 +106,5 @@
lemon/smart_graph.h \
lemon/soplex.h \
+ lemon/static_graph.h \
lemon/suurballe.h \
lemon/time_measure.h \
Index: mon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h (revision 746)
+++ (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 764)
+++ lemon/bfs.h (revision 525)
@@ -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 758)
+++ lemon/bin_heap.h (revision 730)
@@ -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
- ///
- /// \brief Binary heap data structure.
- ///
- /// This class implements the \e binary \e heap data structure.
- /// It fully conforms to the \ref concepts::Heap "heap concept".
- ///
- /// \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
+ ///\ingroup auxdat
+ ///
+ ///\brief A Binary Heap implementation.
+ ///
+ ///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 CMP 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 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 the ordering of the priorities.
+ ///The default is \c std::less.
+ ///
+ ///\sa FibHeap
+ ///\sa Dijkstra
template >
-#endif
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.
+ ///\e
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
+ /// \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 754)
+++ (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/map_extender.h
===================================================================
--- lemon/bits/map_extender.h (revision 765)
+++ lemon/bits/map_extender.h (revision 664)
@@ -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: lemon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h (revision 758)
+++ lemon/bucket_heap.h (revision 730)
@@ -20,7 +20,7 @@
#define LEMON_BUCKET_HEAP_H
-///\ingroup heaps
+///\ingroup auxdat
///\file
-///\brief Bucket heap implementation.
+///\brief Bucket Heap implementation.
#include
@@ -54,39 +54,33 @@
}
- /// \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
+ /// \ingroup auxdat
+ ///
+ /// \brief A Bucket Heap implementation.
+ ///
+ /// This class implements the \e bucket \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. The bucket heap is very simple implementation, it can store
+ /// only integer priorities and it stores for each priority in the
+ /// \f$ [0..C) \f$ range a list of items. So it should be used only when
+ /// the priorities are small. It is not intended to use as dijkstra heap.
+ ///
+ /// \param IM A read and write Item int map, used internally
+ /// to handle the cross references.
+ /// \param MIN If the given parameter is false then instead of the
+ /// minimum value the maximum can be retrivied with the top() and
+ /// prio() member functions.
template
class BucketHeap {
public:
-
- /// Type of the item-int map.
+ /// \e
+ typedef typename IM::Key Item;
+ /// \e
+ typedef int Prio;
+ /// \e
+ typedef std::pair
- Pair;
+ /// \e
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:
@@ -96,8 +90,8 @@
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
+ /// \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.
///
@@ -111,30 +105,28 @@
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
+ /// should be PRE_HEAP (-1) for each element.
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.
+ /// 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 a heap 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(); _first.clear(); _minimum = 0;
@@ -143,5 +135,5 @@
private:
- void relocateLast(int idx) {
+ void relocate_last(int idx) {
if (idx + 1 < int(_data.size())) {
_data[idx] = _data.back();
@@ -183,11 +175,8 @@
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) {
push(p.first, p.second);
@@ -196,9 +185,7 @@
/// \brief Insert an item into the heap with the given priority.
///
- /// This function inserts the given item into the heap with the
- /// given priority.
+ /// 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) {
int idx = _data.size();
@@ -211,8 +198,8 @@
}
- /// \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.
+ ///
+ /// This method returns the item with minimum priority.
+ /// \pre The heap must be nonempty.
Item top() const {
while (_first[_minimum] == -1) {
@@ -222,8 +209,8 @@
}
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
+ /// \brief Returns the minimum priority.
+ ///
+ /// It returns the minimum priority.
+ /// \pre The heap must be nonempty.
Prio prio() const {
while (_first[_minimum] == -1) {
@@ -233,7 +220,7 @@
}
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
+ /// \brief Deletes the item with minimum priority.
+ ///
+ /// This method deletes the item with minimum priority from the heap.
/// \pre The heap must be non-empty.
void pop() {
@@ -244,25 +231,25 @@
_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.
+ relocate_last(idx);
+ }
+
+ /// \brief Deletes \c i from the heap.
+ ///
+ /// This method deletes item \c i from the heap, if \c i was
+ /// already stored in the heap.
+ /// \param i The item to erase.
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.
+ relocate_last(idx);
+ }
+
+
+ /// \brief Returns the priority of \c i.
+ ///
+ /// This function returns the priority of item \c i.
+ /// \pre \c i must be in the heap.
+ /// \param i The item.
Prio operator[](const Item &i) const {
int idx = _iim[i];
@@ -270,10 +257,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.
@@ -289,10 +275,11 @@
}
- /// \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 \c i to \c p.
+ ///
+ /// This method decreases the priority of item \c i to \c p.
+ /// \pre \c i must be stored in the heap with priority at least \c
+ /// p relative to \c Compare.
/// \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];
@@ -305,10 +292,11 @@
}
- /// \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 \c i to \c p.
+ ///
+ /// This method sets the priority of item \c i to \c p.
+ /// \pre \c i must be stored in the heap with priority at most \c
+ /// p relative to \c Compare.
/// \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];
@@ -318,11 +306,11 @@
}
- /// \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.
+ /// \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 {
@@ -332,9 +320,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.
@@ -372,27 +360,21 @@
}; // class BucketHeap
- /// \ingroup heaps
- ///
- /// \brief Simplified bucket heap data structure.
+ /// \ingroup auxdat
+ ///
+ /// \brief A Simplified Bucket Heap implementation.
///
/// 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.
+ /// structure. It does not provide some functionality but it faster
+ /// and simplier data structure than the BucketHeap. The main
+ /// difference is that the BucketHeap stores for every key a double
+ /// linked list while this class stores just simple lists. In the
+ /// other way it does not support erasing each elements just the
+ /// minimal and it does not supports key increasing, decreasing.
+ ///
+ /// \param IM A read and write Item int map, used internally
+ /// to handle the cross references.
+ /// \param MIN If the given parameter is false then instead of the
+ /// minimum value the maximum can be retrivied with the top() and
+ /// prio() member functions.
///
/// \sa BucketHeap
@@ -401,13 +383,8 @@
public:
-
- /// Type of the item-int map.
+ typedef typename IM::Key Item;
+ typedef int Prio;
+ typedef std::pair
- Pair;
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:
@@ -417,8 +394,8 @@
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
+ /// \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.
///
@@ -433,30 +410,29 @@
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
+ /// should be PRE_HEAP (-1) for each element.
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.
+ /// \brief Returns the number of items stored in the heap.
+ ///
+ /// 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.
+ /// \brief Checks if the heap stores no items.
+ ///
+ /// Returns \c true if and only if the heap stores no items.
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.
+ /// \brief Make empty this heap.
+ ///
+ /// Make empty this heap. It does not change the cross reference
+ /// map. If you want to reuse a heap 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(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
@@ -465,8 +441,6 @@
/// \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) {
push(p.first, p.second);
@@ -475,9 +449,7 @@
/// \brief Insert an item into the heap with the given priority.
///
- /// This function inserts the given item into the heap with the
- /// given priority.
+ /// 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) {
int idx;
@@ -500,8 +472,8 @@
}
- /// \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.
+ ///
+ /// This method returns the item with minimum priority.
+ /// \pre The heap must be nonempty.
Item top() const {
while (_first[_minimum] == -1) {
@@ -511,8 +483,8 @@
}
- /// \brief The minimum priority.
- ///
- /// This function returns the minimum priority.
- /// \pre The heap must be non-empty.
+ /// \brief Returns the minimum priority.
+ ///
+ /// It returns the minimum priority.
+ /// \pre The heap must be nonempty.
Prio prio() const {
while (_first[_minimum] == -1) {
@@ -522,7 +494,7 @@
}
- /// \brief Remove the item having minimum priority.
- ///
- /// This function removes the item having minimum priority.
+ /// \brief Deletes the item with minimum priority.
+ ///
+ /// This method deletes the item with minimum priority from the heap.
/// \pre The heap must be non-empty.
void pop() {
@@ -538,13 +510,14 @@
}
- /// \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.
+ /// \brief Returns the priority of \c i.
+ ///
+ /// This function returns the priority of item \c i.
+ /// \warning This operator is not a constant time function
+ /// because it scans the whole data structure to find the proper
+ /// value.
+ /// \pre \c i must be in the heap.
+ /// \param i The item.
Prio operator[](const Item &i) const {
- for (int k = 0; k < int(_first.size()); ++k) {
+ for (int k = 0; k < _first.size(); ++k) {
int idx = _first[k];
while (idx != -1) {
@@ -558,11 +531,11 @@
}
- /// \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.
+ /// \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 {
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc (revision 793)
+++ lemon/cbc.cc (revision 623)
@@ -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 793)
+++ lemon/cbc.h (revision 623)
@@ -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 762)
+++ 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,9 +451,8 @@
}
- /// \brief Sets the tolerance used by the algorithm.
- ///
- /// Sets the tolerance object used by the algorithm.
- /// \return (*this)
- Circulation& tolerance(const Tolerance& tolerance) {
+ /// \brief Sets the tolerance used by algorithm.
+ ///
+ /// Sets the tolerance used by algorithm.
+ Circulation& tolerance(const Tolerance& tolerance) const {
_tol = tolerance;
return *this;
@@ -469,14 +461,13 @@
/// \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;
+ return tolerance;
}
/// \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 793)
+++ lemon/clp.cc (revision 623)
@@ -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 793)
+++ lemon/clp.h (revision 623)
@@ -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 781)
+++ lemon/concepts/digraph.h (revision 627)
@@ -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 781)
+++ lemon/concepts/graph.h (revision 704)
@@ -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 781)
+++ lemon/concepts/graph_components.h (revision 713)
@@ -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 757)
+++ lemon/concepts/heap.h (revision 631)
@@ -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 765)
+++ lemon/concepts/maps.h (revision 576)
@@ -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 793)
+++ lemon/cplex.cc (revision 623)
@@ -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 793)
+++ lemon/cplex.h (revision 623)
@@ -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 764)
+++ lemon/dfs.h (revision 631)
@@ -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 764)
+++ lemon/dijkstra.h (revision 631)
@@ -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 761)
+++ lemon/dim2.h (revision 463)
@@ -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: lemon/fib_heap.h
===================================================================
--- lemon/fib_heap.h (revision 758)
+++ lemon/fib_heap.h (revision 730)
@@ -21,9 +21,8 @@
///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
+///\ingroup auxdat
+///\brief Fibonacci Heap implementation.
#include
-#include
#include
#include
@@ -31,37 +30,42 @@
namespace lemon {
- /// \ingroup heaps
+ /// \ingroup auxdat
///
- /// \brief Fibonacci heap data structure.
+ ///\brief Fibonacci Heap.
///
- /// This class implements the \e Fibonacci \e heap data structure.
- /// It fully conforms to the \ref concepts::Heap "heap concept".
+ ///This class implements the \e Fibonacci \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 CMP specifies the ordering of the priorities. In a heap
+ ///one can change the priority of an item, add or erase an item, etc.
///
- /// 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".
+ ///The methods \ref increase and \ref erase are not efficient in a Fibonacci
+ ///heap. In case of many calls to these operations, it is better to use a
+ ///\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.
+ ///\param PRIO Type of the priority of the items.
+ ///\param IM A read and writable Item int map, used internally
+ ///to handle the cross references.
+ ///\param CMP A class for the ordering of the priorities. The
+ ///default is \c std::less.
+ ///
+ ///\sa BinHeap
+ ///\sa Dijkstra
#ifdef DOXYGEN
- template
+ template
#else
- template >
+ template >
#endif
class FibHeap {
public:
-
- /// Type of the item-int map.
+ ///\e
typedef IM ItemIntMap;
- /// Type of the priorities.
- typedef PR Prio;
- /// Type of the items stored in the heap.
+ ///\e
+ typedef PRIO Prio;
+ ///\e
typedef typename ItemIntMap::Key Item;
- /// Type of the item-priority pairs.
+ ///\e
typedef std::pair
- Pair;
- /// Functor type for comparing the priorities.
+ ///\e
typedef CMP Compare;
@@ -77,8 +81,8 @@
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
+ /// \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.
///
@@ -91,20 +95,16 @@
};
- /// \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
+ ///
+ /// \c map should be given to the constructor, since it is
+ /// used internally to handle the cross references.
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.
+ /// \brief The constructor
+ ///
+ /// \c map should be given to the constructor, since it is used
+ /// internally to handle the cross references. \c comp is an
+ /// object for ordering of the priorities.
FibHeap(ItemIntMap &map, const Compare &comp)
: _minimum(0), _iim(map), _comp(comp), _num() {}
@@ -112,31 +112,41 @@
/// \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 _num; }
- /// \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 _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.
+ /// \brief Make empty this heap.
+ ///
+ /// Make empty this heap. It does not change the cross reference
+ /// map. If you want to reuse a heap 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(); _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) {
+ /// \brief \c item gets to the heap with priority \c value independently
+ /// if \c item was already there.
+ ///
+ /// This method calls \ref push(\c item, \c value) if \c item is not
+ /// stored in the heap and it calls \ref decrease(\c item, \c value) or
+ /// \ref increase(\c item, \c value) otherwise.
+ 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 Adds \c item to the heap with priority \c value.
+ ///
+ /// Adds \c item to the heap with priority \c value.
+ /// \pre \c item must not be stored in the heap.
+ void push (const Item& item, const Prio& value) {
int i=_iim[item];
if ( i < 0 ) {
@@ -159,28 +169,38 @@
_data[_minimum].right_neighbor=i;
_data[i].left_neighbor=_minimum;
- if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
+ if ( _comp( value, _data[_minimum].prio) ) _minimum=i;
} else {
_data[i].right_neighbor=_data[i].left_neighbor=i;
_minimum=i;
}
- _data[i].prio=prio;
+ _data[i].prio=value;
++_num;
}
- /// \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[_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.
+ /// \brief Returns the minimum priority relative to \c Compare.
+ ///
+ /// It returns the minimum priority relative to \c Compare.
+ /// \pre The heap must be nonempty.
+ const Prio& prio() const { return _data[_minimum].prio; }
+
+ /// \brief Returns the priority of \c item.
+ ///
+ /// It returns the priority of \c item.
+ /// \pre \c item must be in the heap.
+ const Prio& operator[](const Item& item) const {
+ return _data[_iim[item]].prio;
+ }
+
+ /// \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() {
@@ -189,5 +209,5 @@
_data[_minimum].in=false;
if ( _data[_minimum].degree!=0 ) {
- makeRoot(_data[_minimum].child);
+ makeroot(_data[_minimum].child);
_minimum=_data[_minimum].child;
balance();
@@ -202,5 +222,5 @@
int last_child=_data[child].left_neighbor;
- makeRoot(child);
+ makeroot(child);
_data[left].right_neighbor=child;
@@ -215,10 +235,8 @@
}
- /// \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.
+ /// \brief Deletes \c item from the heap.
+ ///
+ /// This method deletes \c item from the heap, if \c item was already
+ /// stored in the heap. It is quite inefficient in Fibonacci heaps.
void erase (const Item& item) {
int i=_iim[item];
@@ -235,66 +253,41 @@
}
- /// \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) {
+ /// \brief Decreases the priority of \c item to \c value.
+ ///
+ /// This method decreases the priority of \c item to \c value.
+ /// \pre \c item must be stored in the heap with priority at least \c
+ /// value relative to \c Compare.
+ void decrease (Item item, const Prio& value) {
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;
+ _data[i].prio=value;
int p=_data[i].parent;
- if ( p!=-1 && _comp(prio, _data[p].prio) ) {
+ if ( p!=-1 && _comp(value, _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) {
+ if ( _comp(value, _data[_minimum].prio) ) _minimum=i;
+ }
+
+ /// \brief Increases the priority of \c item to \c value.
+ ///
+ /// This method sets the priority of \c item to \c value. Though
+ /// there is no precondition on the priority of \c item, this
+ /// method should be used only if it is indeed necessary to increase
+ /// (relative to \c Compare) the priority of \c item, because this
+ /// method is inefficient.
+ void increase (Item item, const Prio& value) {
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.
+ push(item, value);
+ }
+
+
+ /// \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.
State state(const Item &item) const {
int i=_iim[item];
@@ -306,9 +299,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.
@@ -373,5 +366,5 @@
}
- void makeRoot(int c) {
+ void makeroot(int c) {
int s=c;
do {
Index: mon/fourary_heap.h
===================================================================
--- lemon/fourary_heap.h (revision 753)
+++ (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 >
-#endif
- class FouraryHeap {
- 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;
-
- /// \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:
- std::vector _data;
- Compare _comp;
- ItemIntMap &_iim;
-
- 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 FouraryHeap(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.
- FouraryHeap(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.
- 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(); }
-
- private:
- static int parent(int i) { return (i-1)/4; }
- static int firstChild(int i) { return 4*i+1; }
-
- bool less(const Pair &p1, const Pair &p2) const {
- return _comp(p1.second, p2.second);
- }
-
- void bubbleUp(int hole, Pair p) {
- int par = parent(hole);
- while( hole>0 && less(p,_data[par]) ) {
- move(_data[par],hole);
- hole = par;
- par = parent(hole);
- }
- move(p, hole);
- }
-
- void bubbleDown(int hole, Pair p, int length) {
- if( length>1 ) {
- int child = firstChild(hole);
- while( child+30) bubbleDown(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.
- void erase(const Item &i) {
- int h = _iim[i];
- int n = _data.size()-1;
- _iim.set(_data[h].first, POST_HEAP);
- if( h=0) s=0;
- return State(s);
- }
-
- /// \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;
- }
- }
-
- /// \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.
- void replace(const Item& i, const Item& j) {
- int idx = _iim[i];
- _iim.set(i, _iim[j]);
- _iim.set(j, idx);
- _data[idx].first = j;
- }
-
- }; // class FouraryHeap
-
-} // namespace lemon
-
-#endif // LEMON_FOURARY_HEAP_H
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h (revision 782)
+++ lemon/full_graph.h (revision 664)
@@ -25,5 +25,5 @@
///\ingroup graphs
///\file
-///\brief FullDigraph and FullGraph classes.
+///\brief FullGraph and FullDigraph classes.
namespace lemon {
@@ -149,24 +149,22 @@
/// \ingroup graphs
///
- /// \brief A directed full graph class.
- ///
- /// FullDigraph is a simple and fast implmenetation of directed full
- /// (complete) graphs. It contains an arc from each node to each node
- /// (including a loop for each node), therefore the number of arcs
- /// is the square of the number of nodes.
- /// This class is completely static and it needs constant memory space.
- /// Thus you can neither add nor delete nodes or arcs, however
- /// the structure can be resized using resize().
- ///
- /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
- /// Most of its member functions and nested classes are documented
- /// only in the concept class.
- ///
- /// \note FullDigraph and FullGraph classes are very similar,
+ /// \brief A full digraph class.
+ ///
+ /// This is a simple and fast directed full graph implementation.
+ /// From each node go arcs to each node (including the source node),
+ /// therefore the number of the arcs in the digraph is the square of
+ /// the node number. This digraph type is completely static, so you
+ /// can neither add nor delete either arcs or nodes, and it needs
+ /// constant space in memory.
+ ///
+ /// This class fully conforms to the \ref concepts::Digraph
+ /// "Digraph concept".
+ ///
+ /// The \c FullDigraph and \c FullGraph classes are very similar,
/// but there are two differences. While this class conforms only
- /// to the \ref concepts::Digraph "Digraph" concept, FullGraph
- /// conforms to the \ref concepts::Graph "Graph" concept,
- /// moreover FullGraph does not contain a loop for each
- /// node as this class does.
+ /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
+ /// class conforms to the \ref concepts::Graph "Graph" concept,
+ /// moreover \c FullGraph does not contain a loop arc for each
+ /// node as \c FullDigraph does.
///
/// \sa FullGraph
@@ -176,7 +174,5 @@
public:
- /// \brief Default constructor.
- ///
- /// Default constructor. The number of nodes and arcs will be zero.
+ /// \brief Constructor
FullDigraph() { construct(0); }
@@ -189,6 +185,6 @@
/// \brief Resizes the digraph
///
- /// This function resizes the digraph. It fully destroys and
- /// rebuilds the structure, therefore the maps of the digraph will be
+ /// Resizes the digraph. The function will fully destroy and
+ /// rebuild the digraph. This cause that the maps of the digraph will
/// reallocated automatically and the previous values will be lost.
void resize(int n) {
@@ -202,7 +198,7 @@
/// \brief Returns the node with the given index.
///
- /// Returns the node with the given index. Since this structure is
- /// completely static, the nodes can be indexed with integers from
- /// the range [0..nodeNum()-1].
+ /// Returns the node with the given index. Since it is a static
+ /// digraph its nodes can be indexed with integers from the range
+ /// [0..nodeNum()-1].
/// \sa index()
Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -210,14 +206,14 @@
/// \brief Returns the index of the given node.
///
- /// Returns the index of the given node. Since this structure is
- /// completely static, the nodes can be indexed with integers from
- /// the range [0..nodeNum()-1].
- /// \sa operator()()
- int index(Node node) const { return Parent::index(node); }
+ /// Returns the index of the given node. Since it is a static
+ /// digraph its nodes can be indexed with integers from the range
+ /// [0..nodeNum()-1].
+ /// \sa operator()
+ int index(const Node& node) const { return Parent::index(node); }
/// \brief Returns the arc connecting the given nodes.
///
/// Returns the arc connecting the given nodes.
- Arc arc(Node u, Node v) const {
+ Arc arc(const Node& u, const Node& v) const {
return Parent::arc(u, v);
}
@@ -525,21 +521,19 @@
/// \brief An undirected full graph class.
///
- /// FullGraph is a simple and fast implmenetation of undirected full
- /// (complete) graphs. It contains an edge between every distinct pair
- /// of nodes, therefore the number of edges is n(n-1)/2.
- /// This class is completely static and it needs constant memory space.
- /// Thus you can neither add nor delete nodes or edges, however
- /// the structure can be resized using resize().
- ///
- /// This type fully conforms to the \ref concepts::Graph "Graph concept".
- /// Most of its member functions and nested classes are documented
- /// only in the concept class.
- ///
- /// \note FullDigraph and FullGraph classes are very similar,
- /// but there are two differences. While FullDigraph
+ /// This is a simple and fast undirected full graph
+ /// implementation. From each node go edge to each other node,
+ /// therefore the number of edges in the graph is \f$n(n-1)/2\f$.
+ /// This graph type is completely static, so you can neither
+ /// add nor delete either edges or nodes, and it needs constant
+ /// space in memory.
+ ///
+ /// This class fully conforms to the \ref concepts::Graph "Graph concept".
+ ///
+ /// The \c FullGraph and \c FullDigraph classes are very similar,
+ /// but there are two differences. While the \c FullDigraph class
/// conforms only to the \ref concepts::Digraph "Digraph" concept,
/// this class conforms to the \ref concepts::Graph "Graph" concept,
- /// moreover this class does not contain a loop for each
- /// node as FullDigraph does.
+ /// moreover \c FullGraph does not contain a loop arc for each
+ /// node as \c FullDigraph does.
///
/// \sa FullDigraph
@@ -549,7 +543,5 @@
public:
- /// \brief Default constructor.
- ///
- /// Default constructor. The number of nodes and edges will be zero.
+ /// \brief Constructor
FullGraph() { construct(0); }
@@ -562,6 +554,6 @@
/// \brief Resizes the graph
///
- /// This function resizes the graph. It fully destroys and
- /// rebuilds the structure, therefore the maps of the graph will be
+ /// Resizes the graph. The function will fully destroy and
+ /// rebuild the graph. This cause that the maps of the graph will
/// reallocated automatically and the previous values will be lost.
void resize(int n) {
@@ -577,7 +569,7 @@
/// \brief Returns the node with the given index.
///
- /// Returns the node with the given index. Since this structure is
- /// completely static, the nodes can be indexed with integers from
- /// the range [0..nodeNum()-1].
+ /// Returns the node with the given index. Since it is a static
+ /// graph its nodes can be indexed with integers from the range
+ /// [0..nodeNum()-1].
/// \sa index()
Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -585,21 +577,21 @@
/// \brief Returns the index of the given node.
///
- /// Returns the index of the given node. Since this structure is
- /// completely static, the nodes can be indexed with integers from
- /// the range [0..nodeNum()-1].
- /// \sa operator()()
- int index(Node node) const { return Parent::index(node); }
+ /// Returns the index of the given node. Since it is a static
+ /// graph its nodes can be indexed with integers from the range
+ /// [0..nodeNum()-1].
+ /// \sa operator()
+ int index(const Node& node) const { return Parent::index(node); }
/// \brief Returns the arc connecting the given nodes.
///
/// Returns the arc connecting the given nodes.
- Arc arc(Node s, Node t) const {
+ Arc arc(const Node& s, const Node& t) const {
return Parent::arc(s, t);
}
- /// \brief Returns the edge connecting the given nodes.
- ///
- /// Returns the edge connecting the given nodes.
- Edge edge(Node u, Node v) const {
+ /// \brief Returns the edge connects the given nodes.
+ ///
+ /// Returns the edge connects the given nodes.
+ Edge edge(const Node& u, const Node& v) const {
return Parent::edge(u, v);
}
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc (revision 793)
+++ lemon/glpk.cc (revision 623)
@@ -57,40 +57,4 @@
int i = glp_add_rows(lp, 1);
glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0);
- return i;
- }
-
- int GlpkBase::_addRow(Value lo, ExprIterator b,
- ExprIterator e, Value up) {
- int i = glp_add_rows(lp, 1);
-
- if (lo == -INF) {
- if (up == INF) {
- glp_set_row_bnds(lp, i, GLP_FR, lo, up);
- } else {
- glp_set_row_bnds(lp, i, GLP_UP, lo, up);
- }
- } else {
- if (up == INF) {
- glp_set_row_bnds(lp, i, GLP_LO, lo, up);
- } else if (lo != up) {
- glp_set_row_bnds(lp, i, GLP_DB, lo, up);
- } else {
- glp_set_row_bnds(lp, i, GLP_FX, lo, up);
- }
- }
-
- std::vector indexes;
- std::vector values;
-
- indexes.push_back(0);
- values.push_back(0);
-
- for(ExprIterator it = b; it != e; ++it) {
- indexes.push_back(it->first);
- values.push_back(it->second);
- }
-
- glp_set_mat_row(lp, i, values.size() - 1,
- &indexes.front(), &values.front());
return i;
}
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h (revision 793)
+++ lemon/glpk.h (revision 697)
@@ -55,5 +55,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/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h (revision 760)
+++ lemon/gomory_hu.h (revision 643)
@@ -360,8 +360,8 @@
/// \c t.
/// \code
- /// GomoryHu gom(g, capacities);
+ /// GomoruHu gom(g, capacities);
/// gom.run();
/// int cnt=0;
- /// for(GomoryHu