# HG changeset patch
# User Alpar Juttner <alpar@cs.elte.hu>
# Date 1257406789 -3600
# Node ID 432c54cec63cbb979f2ae143e3f5724955d6830f
# Parent e746fb14e680fe3c63e3c9362cf2c77fba50238e# Parent 9fbbd802020f985dc6bb617408770635471940f6
Merge #179 (Port the min mean cycle algorithms)
diff -r e746fb14e680 -r 432c54cec63c CMakeLists.txt
--- a/CMakeLists.txt Tue Aug 18 10:08:28 2009 +0200
+++ b/CMakeLists.txt Thu Nov 05 08:39:49 2009 +0100
@@ -35,6 +35,8 @@
CHECK_TYPE_SIZE("long long" LONG_LONG)
SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
+INCLUDE(FindPythonInterp)
+
ENABLE_TESTING()
ADD_SUBDIRECTORY(lemon)
diff -r e746fb14e680 -r 432c54cec63c Makefile.am
--- a/Makefile.am Tue Aug 18 10:08:28 2009 +0200
+++ b/Makefile.am Thu Nov 05 08:39:49 2009 +0100
@@ -17,6 +17,7 @@
cmake/FindCPLEX.cmake \
cmake/FindGLPK.cmake \
cmake/FindCOIN.cmake \
+ cmake/LEMONConfig.cmake.in \
cmake/version.cmake.in \
cmake/version.cmake \
cmake/nsis/lemon.ico \
diff -r e746fb14e680 -r 432c54cec63c configure.ac
--- a/configure.ac Tue Aug 18 10:08:28 2009 +0200
+++ b/configure.ac Thu Nov 05 08:39:49 2009 +0100
@@ -41,6 +41,7 @@
AC_PROG_LIBTOOL
AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
+AC_CHECK_PROG([python_found],[python],[yes],[no])
AC_CHECK_PROG([gs_found],[gs],[yes],[no])
dnl Detect Intel compiler.
diff -r e746fb14e680 -r 432c54cec63c doc/CMakeLists.txt
--- a/doc/CMakeLists.txt Tue Aug 18 10:08:28 2009 +0200
+++ b/doc/CMakeLists.txt Thu Nov 05 08:39:49 2009 +0100
@@ -9,7 +9,7 @@
@ONLY
)
-IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
+IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha)
ADD_CUSTOM_TARGET(html
@@ -28,6 +28,7 @@
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
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}
)
diff -r e746fb14e680 -r 432c54cec63c doc/Doxyfile.in
--- a/doc/Doxyfile.in Tue Aug 18 10:08:28 2009 +0200
+++ b/doc/Doxyfile.in Thu Nov 05 08:39:49 2009 +0100
@@ -1,4 +1,4 @@
-# Doxyfile 1.5.7.1
+# Doxyfile 1.5.9
#---------------------------------------------------------------------------
# Project related configuration options
@@ -21,7 +21,6 @@
JAVADOC_AUTOBRIEF = NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
-DETAILS_AT_TOP = YES
INHERIT_DOCS = NO
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
@@ -91,7 +90,8 @@
"@abs_top_srcdir@/lemon/concepts" \
"@abs_top_srcdir@/demo" \
"@abs_top_srcdir@/tools" \
- "@abs_top_srcdir@/test/test_tools.h"
+ "@abs_top_srcdir@/test/test_tools.h" \
+ "@abs_top_builddir@/doc/references.dox"
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.h \
*.cc \
@@ -223,7 +223,7 @@
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
-# Configuration::additions related to external references
+# Options related to the search engine
#---------------------------------------------------------------------------
TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ "
GENERATE_TAGFILE = html/lemon.tag
diff -r e746fb14e680 -r 432c54cec63c doc/Makefile.am
--- a/doc/Makefile.am Tue Aug 18 10:08:28 2009 +0200
+++ b/doc/Makefile.am Thu Nov 05 08:39:49 2009 +0100
@@ -66,7 +66,19 @@
exit 1; \
fi
-html-local: $(DOC_PNG_IMAGES)
+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
if test ${doxygen_found} = yes; then \
cd doc; \
doxygen Doxyfile; \
diff -r e746fb14e680 -r 432c54cec63c doc/groups.dox
--- a/doc/groups.dox Tue Aug 18 10:08:28 2009 +0200
+++ b/doc/groups.dox Thu Nov 05 08:39:49 2009 +0100
@@ -226,14 +226,6 @@
*/
/**
-@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
\brief %Path structures implemented in LEMON.
@@ -246,7 +238,36 @@
efficient to have e.g. the Dijkstra algorithm to store its result in
any kind of path structure.
-\sa lemon::concepts::Path
+\sa \ref concepts::Path "Path concept"
+*/
+
+/**
+@defgroup heaps Heap Structures
+@ingroup datas
+\brief %Heap structures implemented in LEMON.
+
+This group contains the heap structures implemented in LEMON.
+
+LEMON provides several heap classes. They are efficient implementations
+of the abstract data type \e priority \e queue. They store items with
+specified values called \e priorities in such a way that finding and
+removing the item with minimum priority are efficient.
+The basic operations are adding and erasing items, changing the priority
+of an item, etc.
+
+Heaps are crucial in several algorithms, such as Dijkstra and Prim.
+The heap implementations have the same interface, thus any of them can be
+used easily in such algorithms.
+
+\sa \ref concepts::Heap "Heap concept"
+*/
+
+/**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group contains two dimensional data storages implemented in LEMON.
*/
/**
@@ -259,6 +280,28 @@
*/
/**
+@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
implemented in LEMON.
@@ -273,7 +316,8 @@
\brief Common graph search algorithms.
This group contains the common graph search algorithms, namely
-\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
+\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
+\ref clrs01algorithms.
*/
/**
@@ -281,7 +325,8 @@
@ingroup algs
\brief Algorithms for finding shortest paths.
-This group contains the algorithms for finding shortest paths in digraphs.
+This group contains the algorithms for finding shortest paths in digraphs
+\ref clrs01algorithms.
- \ref Dijkstra algorithm for finding shortest paths from a source node
when all arc lengths are non-negative.
@@ -298,12 +343,21 @@
*/
/**
+@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
\brief Algorithms for finding maximum flows.
This group contains the algorithms for finding maximum flows and
-feasible circulations.
+feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
The \e maximum \e flow \e problem is to find a flow of maximum value between
a single source and a single target. Formally, there is a \f$G=(V,A)\f$
@@ -318,12 +372,16 @@
\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]
LEMON contains several algorithms for solving maximum flow problems:
-- \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.
+- \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 "Preflow" algorithm provides the
+In most cases the \ref 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
problem of maximum flow.
@@ -341,18 +399,22 @@
\brief Algorithms for finding minimum cost flows and circulations.
This group contains the algorithms for finding minimum cost flows and
-circulations. For more information about this problem and its dual
-solution see \ref min_cost_flow "Minimum Cost Flow Problem".
+circulations \ref amo93networkflows. 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.
+ pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
- \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
- cost scaling.
+ cost scaling \ref goldberg90approximation, \ref goldberg97efficient,
+ \ref bunnagel98efficient.
- \ref CapacityScaling Successive Shortest %Path algorithm with optional
- capacity scaling.
- - \ref CancelAndTighten The Cancel and Tighten algorithm.
- - \ref CycleCanceling Cycle-Canceling algorithms.
+ capacity scaling \ref edmondskarp72theoretical.
+ - \ref CancelAndTighten The Cancel and Tighten algorithm
+ \ref goldberg89cyclecanceling.
+ - \ref CycleCanceling Cycle-Canceling algorithms
+ \ref klein67primal, \ref goldberg89cyclecanceling.
In general NetworkSimplex is the most efficient implementation,
but in special cases other algorithms could be faster.
@@ -375,7 +437,7 @@
cut is the \f$X\f$ solution of the next optimization problem:
\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:
@@ -425,30 +487,6 @@
*/
/**
-@defgroup graph_properties Connectivity and Other Graph Properties
-@ingroup algs
-\brief Algorithms for discovering the graph properties
-
-This group contains the algorithms for discovering the graph properties
-like connectivity, bipartiteness, euler property, simplicity etc.
-
-\image html edge_biconnected_components.png
-\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
-*/
-
-/**
-@defgroup planar Planarity Embedding and Drawing
-@ingroup algs
-\brief Algorithms for planarity checking, embedding and drawing
-
-This group contains the algorithms for planarity checking,
-embedding and drawing.
-
-\image html planar.png
-\image latex planar.eps "Plane graph" width=\textwidth
-*/
-
-/**
@defgroup matching Matching Algorithms
@ingroup algs
\brief Algorithms for finding matchings in graphs and bipartite graphs.
@@ -489,12 +527,36 @@
*/
/**
-@defgroup spantree Minimum Spanning Tree Algorithms
+@defgroup graph_properties Connectivity and Other Graph Properties
@ingroup algs
-\brief Algorithms for finding minimum cost spanning trees and arborescences.
+\brief Algorithms for discovering the graph properties
-This group contains the algorithms for finding minimum cost spanning
-trees and arborescences.
+This group contains the algorithms for discovering the graph properties
+like connectivity, bipartiteness, euler property, simplicity etc.
+
+\image html connected_components.png
+\image latex connected_components.eps "Connected components" width=\textwidth
+*/
+
+/**
+@defgroup planar Planarity Embedding and Drawing
+@ingroup algs
+\brief Algorithms for planarity checking, embedding and drawing
+
+This group contains the algorithms for planarity checking,
+embedding and drawing.
+
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
+*/
+
+/**
+@defgroup approx Approximation Algorithms
+@ingroup algs
+\brief Approximation algorithms.
+
+This group contains the approximation and heuristic algorithms
+implemented in LEMON.
*/
/**
@@ -507,15 +569,6 @@
*/
/**
-@defgroup approx Approximation Algorithms
-@ingroup algs
-\brief Approximation algorithms.
-
-This group contains the approximation and heuristic algorithms
-implemented in LEMON.
-*/
-
-/**
@defgroup gen_opt_group General Optimization Tools
\brief This group contains some general optimization frameworks
implemented in LEMON.
@@ -525,13 +578,16 @@
*/
/**
-@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.
+\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.
+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.
*/
/**
@@ -621,7 +677,7 @@
*/
/**
-@defgroup dimacs_group DIMACS format
+@defgroup dimacs_group DIMACS Format
@ingroup io_group
\brief Read and write files in DIMACS format
@@ -670,8 +726,8 @@
@ingroup concept
\brief Skeleton and concept checking classes for graph structures
-This group contains the skeletons and concept checking classes of LEMON's
-graph structures and helper classes used to implement these.
+This group contains the skeletons and concept checking classes of
+graph structures.
*/
/**
@@ -683,6 +739,15 @@
*/
/**
+@defgroup tools Standalone Utility Applications
+
+Some utility applications are listed here.
+
+The standard compilation procedure (<tt>./configure;make</tt>) will compile
+them, as well.
+*/
+
+/**
\anchor demoprograms
@defgroup demos Demo Programs
@@ -694,13 +759,4 @@
<tt>make check</tt> commands.
*/
-/**
-@defgroup tools Standalone Utility Applications
-
-Some utility applications are listed here.
-
-The standard compilation procedure (<tt>./configure;make</tt>) will compile
-them, as well.
-*/
-
}
diff -r e746fb14e680 -r 432c54cec63c doc/mainpage.dox
--- a/doc/mainpage.dox Tue Aug 18 10:08:28 2009 +0200
+++ b/doc/mainpage.dox Thu Nov 05 08:39:49 2009 +0100
@@ -21,14 +21,11 @@
\section intro Introduction
-\subsection whatis What is LEMON
-
-LEMON stands for <b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
-and <b>O</b>ptimization in <b>N</b>etworks.
-It is a C++ template
-library aimed at combinatorial optimization tasks which
-often involve in working
-with graphs.
+<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
+and <b>O</b>ptimization in <b>N</b>etworks</i>.
+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.
<b>
LEMON is an <a class="el" href="http://opensource.org/">open source</a>
@@ -38,7 +35,16 @@
\ref license "license terms".
</b>
-\subsection howtoread How to read the documentation
+The project is maintained by the
+<a href="http://www.cs.elte.hu/egres/">Egerváry Research Group on
+Combinatorial Optimization</a> \ref egres
+at the Operations Research Department of the
+<a href="http://www.elte.hu/">Eötvös Loránd University,
+Budapest</a>, Hungary.
+LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
+initiative \ref coinor.
+
+\section howtoread How to Read the Documentation
If you would like to get to know the library, see
<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
diff -r e746fb14e680 -r 432c54cec63c doc/min_cost_flow.dox
--- a/doc/min_cost_flow.dox Tue Aug 18 10:08:28 2009 +0200
+++ b/doc/min_cost_flow.dox Thu Nov 05 08:39:49 2009 +0100
@@ -26,7 +26,7 @@
The \e minimum \e cost \e flow \e problem is to find a feasible flow of
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.
+and arc costs \ref amo93networkflows.
Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and
diff -r e746fb14e680 -r 432c54cec63c doc/references.bib
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/doc/references.bib Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,301 @@
+%%%%% 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,
+}
diff -r e746fb14e680 -r 432c54cec63c lemon/Makefile.am
--- a/lemon/Makefile.am Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/Makefile.am Thu Nov 05 08:39:49 2009 +0100
@@ -57,8 +57,10 @@
lemon/adaptors.h \
lemon/arg_parser.h \
lemon/assert.h \
+ lemon/bellman_ford.h \
lemon/bfs.h \
lemon/bin_heap.h \
+ lemon/binom_heap.h \
lemon/bucket_heap.h \
lemon/cbc.h \
lemon/circulation.h \
@@ -78,6 +80,7 @@
lemon/error.h \
lemon/euler.h \
lemon/fib_heap.h \
+ lemon/fourary_heap.h \
lemon/full_graph.h \
lemon/glpk.h \
lemon/gomory_hu.h \
@@ -87,6 +90,7 @@
lemon/howard.h \
lemon/hypercube_graph.h \
lemon/karp.h \
+ lemon/kary_heap.h \
lemon/kruskal.h \
lemon/hao_orlin.h \
lemon/lgf_reader.h \
@@ -95,13 +99,13 @@
lemon/lp.h \
lemon/lp_base.h \
lemon/lp_skeleton.h \
- lemon/list_graph.h \
lemon/maps.h \
lemon/matching.h \
lemon/math.h \
lemon/min_cost_arborescence.h \
lemon/nauty_reader.h \
lemon/network_simplex.h \
+ lemon/pairing_heap.h \
lemon/path.h \
lemon/preflow.h \
lemon/radix_heap.h \
diff -r e746fb14e680 -r 432c54cec63c lemon/bellman_ford.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/bellman_ford.h Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,1100 @@
+/* -*- 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 <lemon/bits/path_dump.h>
+#include <lemon/core.h>
+#include <lemon/error.h>
+#include <lemon/maps.h>
+#include <lemon/path.h>
+
+#include <limits>
+
+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<V>::has_infinity>
+ struct BellmanFordDefaultOperationTraits {
+ /// \e
+ typedef V Value;
+ /// \brief Gives back the zero value of the type.
+ static Value zero() {
+ return static_cast<Value>(0);
+ }
+ /// \brief Gives back the positive infinity value of the type.
+ static Value infinity() {
+ return std::numeric_limits<Value>::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 <typename V>
+ struct BellmanFordDefaultOperationTraits<V, false> {
+ typedef V Value;
+ static Value zero() {
+ return static_cast<Value>(0);
+ }
+ static Value infinity() {
+ return std::numeric_limits<Value>::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<typename GR, typename LEN>
+ 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<Value> 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<typename GR::Arc> 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<typename LEN::Value> 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
+ /// <tt>O(ne)</tt>.
+ ///
+ /// 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<int>".
+#ifdef DOXYGEN
+ template <typename GR, typename LEN, typename TR>
+#else
+ template <typename GR=ListDigraph,
+ typename LEN=typename GR::template ArcMap<int>,
+ typename TR=BellmanFordDefaultTraits<GR,LEN> >
+#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<Digraph, PredMap> 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<bool> MaskMap;
+ MaskMap *_mask;
+
+ std::vector<Node> _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 <class T>
+ 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 <class T>
+ struct SetPredMap
+ : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
+ typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
+ };
+
+ template <class T>
+ 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 <class T>
+ struct SetDistMap
+ : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
+ typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
+ };
+
+ template <class T>
+ 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 <class T>
+ struct SetOperationTraits
+ : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
+ typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >
+ 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 <tt>(*this)</tt>
+ 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 <tt>(*this)</tt>
+ 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 <tt>(*this)</tt>
+ 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
+ /// <tt>k+1</tt> 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<Node> nextProcess;
+ std::vector<Value> 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
+ /// <tt>k+1</tt> 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<Node> 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<Node>(*this) == static_cast<Node>(it);
+ }
+ bool operator!=(const ActiveIt& it) const {
+ return static_cast<Node>(*this) != static_cast<Node>(it);
+ }
+ bool operator<(const ActiveIt& it) const {
+ return static_cast<Node>(*this) < static_cast<Node>(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<Digraph> negativeCycle() {
+ typename Digraph::template NodeMap<int> state(*_gr, -1);
+ lemon::Path<Digraph> 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 <typename GR, typename LEN>
+ 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<Value> 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<typename GR::Arc> 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<Value> 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<Digraph> 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 <typename GR, typename LEN>
+ class BellmanFordWizardBase
+ : public BellmanFordWizardDefaultTraits<GR, LEN> {
+
+ typedef BellmanFordWizardDefaultTraits<GR, LEN> 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<void*>(const_cast<GR*>(&gr))),
+ _length(reinterpret_cast<void*>(const_cast<LEN*>(&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 TR>
+ 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<Digraph,LengthMap,TR>
+ bf(*reinterpret_cast<const Digraph*>(Base::_graph),
+ *reinterpret_cast<const LengthMap*>(Base::_length));
+ if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+ if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(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<Digraph,LengthMap,TR>
+ bf(*reinterpret_cast<const Digraph*>(Base::_graph),
+ *reinterpret_cast<const LengthMap*>(Base::_length));
+ if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+ if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
+ bf.run(s);
+ if (Base::_path) *reinterpret_cast<Path*>(Base::_path) = bf.path(t);
+ if (Base::_di) *reinterpret_cast<Value*>(Base::_di) = bf.dist(t);
+ return bf.reached(t);
+ }
+
+ template<class T>
+ 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<class T>
+ BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) {
+ Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
+ return BellmanFordWizard<SetPredMapBase<T> >(*this);
+ }
+
+ template<class T>
+ 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<class T>
+ BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) {
+ Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
+ return BellmanFordWizard<SetDistMapBase<T> >(*this);
+ }
+
+ template<class T>
+ 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<class T>
+ BellmanFordWizard<SetPathBase<T> > path(const T &t)
+ {
+ Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
+ return BellmanFordWizard<SetPathBase<T> >(*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<void*>(const_cast<Value*>(&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<typename GR, typename LEN>
+ BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
+ bellmanFord(const GR& digraph,
+ const LEN& length)
+ {
+ return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
+ }
+
+} //END OF NAMESPACE LEMON
+
+#endif
+
diff -r e746fb14e680 -r 432c54cec63c lemon/bfs.h
--- a/lemon/bfs.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/bfs.h Thu Nov 05 08:39:49 2009 +0100
@@ -47,7 +47,7 @@
///
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
///Instantiates a \c PredMap.
@@ -62,7 +62,8 @@
///The type of the map that indicates which nodes are processed.
///The type of the map that indicates which nodes are processed.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///By default it is a NullMap.
typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
///Instantiates a \c ProcessedMap.
@@ -81,7 +82,7 @@
///The type of the map that indicates which nodes are reached.
///The type of the map that indicates which nodes are reached.
- ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap<bool> ReachedMap;
///Instantiates a \c ReachedMap.
@@ -96,7 +97,7 @@
///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 meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<int> DistMap;
///Instantiates a \c DistMap.
@@ -225,7 +226,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c PredMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
typedef Bfs< Digraph, SetPredMapTraits<T> > Create;
@@ -245,7 +246,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c DistMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
typedef Bfs< Digraph, SetDistMapTraits<T> > Create;
@@ -265,7 +266,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c ReachedMap type.
- ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
template <class T>
struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
@@ -285,7 +286,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c ProcessedMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
typedef Bfs< Digraph, SetProcessedMapTraits<T> > Create;
@@ -413,8 +414,8 @@
///\name Execution Control
///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 more control on the execution, first you have to call
- ///\ref init(), then you can add several source nodes with
+ ///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 one of the \ref start() functions.
@@ -737,9 +738,9 @@
///@{
- ///The shortest path to a node.
+ ///The shortest path to the given node.
- ///Returns the shortest path to a node.
+ ///Returns the shortest path to the given node from the root(s).
///
///\warning \c t should be reached from the root(s).
///
@@ -747,9 +748,9 @@
///must be called before using this function.
Path path(Node t) const { return Path(*G, *_pred, t); }
- ///The distance of a node from the root(s).
+ ///The distance of the given node from the root(s).
- ///Returns the distance of a 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.
@@ -758,29 +759,31 @@
///must be called before using this function.
int dist(Node v) const { return (*_dist)[v]; }
- ///Returns the 'previous arc' of the shortest path tree for a node.
-
+ ///\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 the 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().
+ ///tree used in \ref predNode() and \ref predMap().
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
Arc predArc(Node v) const { return (*_pred)[v];}
- ///Returns the 'previous node' of the shortest path tree for a node.
-
+ ///\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 the node \c v, i.e. it returns the last but one node
- ///from a shortest path from a root to \c v. It is \c INVALID
+ ///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().
+ ///tree used in \ref predArc() and \ref predMap().
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
@@ -801,13 +804,13 @@
///predecessor arcs.
///
///Returns a const reference to the node map that stores the predecessor
- ///arcs, which form the shortest path tree.
+ ///arcs, which form the shortest path tree (forest).
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
const PredMap &predMap() const { return *_pred;}
- ///Checks if a node is reached from the root(s).
+ ///Checks if the given node is reached from the root(s).
///Returns \c true if \c v is reached from the root(s).
///
@@ -833,7 +836,7 @@
///
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
///Instantiates a PredMap.
@@ -848,7 +851,7 @@
///The type of the map that indicates which nodes are processed.
///The type of the map that indicates which nodes are processed.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
///Instantiates a ProcessedMap.
@@ -868,7 +871,7 @@
///The type of the map that indicates which nodes are reached.
///The type of the map that indicates which nodes are reached.
- ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap<bool> ReachedMap;
///Instantiates a ReachedMap.
@@ -883,7 +886,7 @@
///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 meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<int> DistMap;
///Instantiates a DistMap.
@@ -898,18 +901,14 @@
///The type of the shortest paths.
///The type of the shortest paths.
- ///It must meet the \ref concepts::Path "Path" concept.
+ ///It must conform to the \ref concepts::Path "Path" concept.
typedef lemon::Path<Digraph> Path;
};
/// Default traits class used by BfsWizard
- /// 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.
+ /// Default traits class used by BfsWizard.
+ /// \tparam GR The type of the digraph.
template<class GR>
class BfsWizardBase : public BfsWizardDefaultTraits<GR>
{
@@ -937,7 +936,7 @@
public:
/// Constructor.
- /// This constructor does not require parameters, therefore it initiates
+ /// This constructor does not require parameters, it initiates
/// all of the attributes to \c 0.
BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
_dist(0), _path(0), _di(0) {}
@@ -967,7 +966,6 @@
{
typedef TR Base;
- ///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
typedef typename Digraph::Node Node;
@@ -975,16 +973,10 @@
typedef typename Digraph::Arc Arc;
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;
public:
@@ -1067,11 +1059,12 @@
static PredMap *createPredMap(const Digraph &) { return 0; };
SetPredMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting PredMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the predecessor map.
///
- ///\ref named-func-param "Named parameter"
- ///for setting PredMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that stores the predecessor arcs of the nodes.
template<class T>
BfsWizard<SetPredMapBase<T> > predMap(const T &t)
{
@@ -1085,11 +1078,12 @@
static ReachedMap *createReachedMap(const Digraph &) { return 0; };
SetReachedMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting ReachedMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the reached map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting ReachedMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that indicates which nodes are reached.
template<class T>
BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
{
@@ -1103,11 +1097,13 @@
static DistMap *createDistMap(const Digraph &) { return 0; };
SetDistMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting DistMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the distance map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting DistMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that stores the distances of the nodes calculated
+ ///by the algorithm.
template<class T>
BfsWizard<SetDistMapBase<T> > distMap(const T &t)
{
@@ -1121,11 +1117,12 @@
static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
SetProcessedMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting ProcessedMap object.
+
+ ///\brief \ref named-func-param "Named parameter" for setting
+ ///the processed map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting ProcessedMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that indicates which nodes are processed.
template<class T>
BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
{
@@ -1264,7 +1261,7 @@
/// \brief The type of the map that indicates which nodes are reached.
///
/// The type of the map that indicates which nodes are reached.
- /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap<bool> ReachedMap;
/// \brief Instantiates a ReachedMap.
@@ -1425,8 +1422,8 @@
/// \name Execution Control
/// 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 more control on the execution, first you have to call
- /// \ref init(), then you can add several source nodes with
+ /// 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 one of the \ref start() functions.
@@ -1735,7 +1732,7 @@
///@{
- /// \brief Checks if a node is reached from the root(s).
+ /// \brief Checks if the given node is reached from the root(s).
///
/// Returns \c true if \c v is reached from the root(s).
///
diff -r e746fb14e680 -r 432c54cec63c lemon/bin_heap.h
--- a/lemon/bin_heap.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/bin_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -19,9 +19,9 @@
#ifndef LEMON_BIN_HEAP_H
#define LEMON_BIN_HEAP_H
-///\ingroup auxdat
+///\ingroup heaps
///\file
-///\brief Binary Heap implementation.
+///\brief Binary heap implementation.
#include <vector>
#include <utility>
@@ -29,45 +29,41 @@
namespace lemon {
- ///\ingroup auxdat
+ /// \ingroup heaps
///
- ///\brief A Binary Heap implementation.
+ /// \brief Binary heap data structure.
///
- ///This class implements the \e binary \e heap data structure.
+ /// This class implements the \e binary \e heap data structure.
+ /// It fully conforms to the \ref concepts::Heap "heap concept".
///
- ///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<PR>.
- ///
- ///\sa FibHeap
- ///\sa Dijkstra
+ /// \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<PR>.
+#ifdef DOXYGEN
+ template <typename PR, typename IM, typename CMP>
+#else
template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
class BinHeap {
+ public:
- public:
- ///\e
+ /// Type of the item-int map.
typedef IM ItemIntMap;
- ///\e
+ /// Type of the priorities.
typedef PR Prio;
- ///\e
+ /// Type of the items stored in the heap.
typedef typename ItemIntMap::Key Item;
- ///\e
+ /// Type of the item-priority pairs.
typedef std::pair<Item,Prio> Pair;
- ///\e
+ /// Functor type for comparing the priorities.
typedef CMP Compare;
- /// \brief Type to represent the items states.
+ /// \brief Type to represent the states of the items.
///
- /// 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
+ /// 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
@@ -84,42 +80,43 @@
ItemIntMap &_iim;
public:
- /// \brief The constructor.
+
+ /// \brief 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 (<tt>-1</tt>) for every item.
+ /// 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 (<tt>-1</tt>) for each item.
explicit BinHeap(ItemIntMap &map) : _iim(map) {}
- /// \brief The constructor.
+ /// \brief 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.
+ /// 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 (<tt>-1</tt>) for each item.
+ /// \param comp The function object used for comparing the priorities.
BinHeap(ItemIntMap &map, const Compare &comp)
: _iim(map), _comp(comp) {}
- /// The number of items stored in the heap.
+ /// \brief The number of items stored in the heap.
///
- /// \brief Returns 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 Checks if the heap stores no items.
+ /// \brief Check if the heap is empty.
///
- /// Returns \c true if and only if the heap stores no items.
+ /// This function returns \c true if the heap is empty.
bool empty() const { return _data.empty(); }
- /// \brief Make empty this heap.
+ /// \brief Make the heap empty.
///
- /// 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.
+ /// 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();
}
@@ -127,12 +124,12 @@
private:
static int parent(int i) { return (i-1)/2; }
- static int second_child(int i) { return 2*i+2; }
+ static int secondChild(int i) { return 2*i+2; }
bool less(const Pair &p1, const Pair &p2) const {
return _comp(p1.second, p2.second);
}
- int bubble_up(int hole, Pair p) {
+ int bubbleUp(int hole, Pair p) {
int par = parent(hole);
while( hole>0 && less(p,_data[par]) ) {
move(_data[par],hole);
@@ -143,8 +140,8 @@
return hole;
}
- int bubble_down(int hole, Pair p, int length) {
- int child = second_child(hole);
+ int bubbleDown(int hole, Pair p, int length) {
+ int child = secondChild(hole);
while(child < length) {
if( less(_data[child-1], _data[child]) ) {
--child;
@@ -153,7 +150,7 @@
goto ok;
move(_data[child], hole);
hole = child;
- child = second_child(hole);
+ child = secondChild(hole);
}
child--;
if( child<length && less(_data[child], p) ) {
@@ -171,87 +168,91 @@
}
public:
+
/// \brief Insert a pair of item and priority into the heap.
///
- /// Adds \c p.first to the heap with priority \c p.second.
+ /// This function inserts \c p.first to the heap with priority
+ /// \c p.second.
/// \param p The pair to insert.
+ /// \pre \c p.first must not be stored in the heap.
void push(const Pair &p) {
int n = _data.size();
_data.resize(n+1);
- bubble_up(n, p);
+ bubbleUp(n, p);
}
- /// \brief Insert an item into the heap with the given heap.
+ /// \brief Insert an item into the heap with the given priority.
///
- /// Adds \c i to the heap with priority \c p.
+ /// This function inserts the given item into the heap with the
+ /// given priority.
/// \param i The item to insert.
/// \param p The priority of the item.
+ /// \pre \e i must not be stored in the heap.
void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
- /// \brief Returns the item with minimum priority relative to \c Compare.
+ /// \brief Return the item having minimum priority.
///
- /// This method returns the item with minimum priority relative to \c
- /// Compare.
- /// \pre The heap must be nonempty.
+ /// This function returns the item having minimum priority.
+ /// \pre The heap must be non-empty.
Item top() const {
return _data[0].first;
}
- /// \brief Returns the minimum priority relative to \c Compare.
+ /// \brief The minimum priority.
///
- /// It returns the minimum priority relative to \c Compare.
- /// \pre The heap must be nonempty.
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
Prio prio() const {
return _data[0].second;
}
- /// \brief Deletes the item with minimum priority relative to \c Compare.
+ /// \brief Remove the item having minimum priority.
///
- /// This method deletes the item with minimum priority relative to \c
- /// Compare from the heap.
+ /// This function removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {
int n = _data.size()-1;
_iim.set(_data[0].first, POST_HEAP);
if (n > 0) {
- bubble_down(0, _data[n], n);
+ bubbleDown(0, _data[n], n);
}
_data.pop_back();
}
- /// \brief Deletes \c i from the heap.
+ /// \brief Remove the given item 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.
+ /// 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 < n ) {
- if ( bubble_up(h, _data[n]) == h) {
- bubble_down(h, _data[n], n);
+ if ( bubbleUp(h, _data[n]) == h) {
+ bubbleDown(h, _data[n], n);
}
}
_data.pop_back();
}
-
- /// \brief Returns the priority of \c i.
+ /// \brief The priority of the given item.
///
- /// This function returns the priority of item \c i.
+ /// This function returns the priority of the given item.
/// \param i The item.
- /// \pre \c i must be in the heap.
+ /// \pre \e i must be in the heap.
Prio operator[](const Item &i) const {
int idx = _iim[i];
return _data[idx].second;
}
- /// \brief \c i gets to the heap with priority \c p independently
- /// if \c i was already there.
+ /// \brief Set the priority of an item or insert it, if it is
+ /// not stored in the heap.
///
- /// 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.
+ /// This method sets the priority of the given item if it is
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
/// \param i The item.
/// \param p The priority.
void set(const Item &i, const Prio &p) {
@@ -260,44 +261,42 @@
push(i,p);
}
else if( _comp(p, _data[idx].second) ) {
- bubble_up(idx, Pair(i,p));
+ bubbleUp(idx, Pair(i,p));
}
else {
- bubble_down(idx, Pair(i,p), _data.size());
+ bubbleDown(idx, Pair(i,p), _data.size());
}
}
- /// \brief Decreases the priority of \c i to \c p.
+ /// \brief Decrease the priority of an item to the given value.
///
- /// This method decreases the priority of item \c i to \c p.
+ /// This function decreases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
- /// \pre \c i must be stored in the heap with priority at least \c
- /// p relative to \c Compare.
+ /// \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];
- bubble_up(idx, Pair(i,p));
+ bubbleUp(idx, Pair(i,p));
}
- /// \brief Increases the priority of \c i to \c p.
+ /// \brief Increase the priority of an item to the given value.
///
- /// This method sets the priority of item \c i to \c p.
+ /// This function increases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
- /// \pre \c i must be stored in the heap with priority at most \c
- /// p relative to \c Compare.
+ /// \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];
- bubble_down(idx, Pair(i,p), _data.size());
+ bubbleDown(idx, Pair(i,p), _data.size());
}
- /// \brief Returns if \c item is in, has already been in, or has
- /// never been in the heap.
+ /// \brief Return the state of an item.
///
- /// 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.
+ /// This method returns \c PRE_HEAP if the given item has never
+ /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+ /// and \c POST_HEAP otherwise.
+ /// In the latter case it is possible that the item will get back
+ /// to the heap again.
/// \param i The item.
State state(const Item &i) const {
int s = _iim[i];
@@ -306,11 +305,11 @@
return State(s);
}
- /// \brief Sets the state of the \c item in the heap.
+ /// \brief Set the state of an 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.
+ /// 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) {
@@ -327,12 +326,13 @@
}
}
- /// \brief Replaces an item in the heap.
+ /// \brief Replace 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.
+ /// 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]);
diff -r e746fb14e680 -r 432c54cec63c lemon/binom_heap.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/binom_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,445 @@
+/* -*- 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 <vector>
+#include <utility>
+#include <functional>
+#include <lemon/math.h>
+#include <lemon/counter.h>
+
+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<PR>.
+#ifdef DOXYGEN
+ template <typename PR, typename IM, typename CMP>
+#else
+ template <typename PR, typename IM, typename CMP = std::less<PR> >
+#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 (<tt>-1</tt>) 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<Store> _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 (<tt>-1</tt>) 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 (<tt>-1</tt>) 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
+
diff -r e746fb14e680 -r 432c54cec63c lemon/bits/edge_set_extender.h
--- a/lemon/bits/edge_set_extender.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/bits/edge_set_extender.h Thu Nov 05 08:39:49 2009 +0100
@@ -537,7 +537,7 @@
typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
public:
- ArcMap(const Graph& _g)
+ explicit ArcMap(const Graph& _g)
: Parent(_g) {}
ArcMap(const Graph& _g, const _Value& _v)
: Parent(_g, _v) {}
@@ -561,7 +561,7 @@
typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
public:
- EdgeMap(const Graph& _g)
+ explicit EdgeMap(const Graph& _g)
: Parent(_g) {}
EdgeMap(const Graph& _g, const _Value& _v)
diff -r e746fb14e680 -r 432c54cec63c lemon/bits/graph_extender.h
--- a/lemon/bits/graph_extender.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/bits/graph_extender.h Thu Nov 05 08:39:49 2009 +0100
@@ -604,7 +604,7 @@
typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
public:
- NodeMap(const Graph& graph)
+ explicit NodeMap(const Graph& graph)
: Parent(graph) {}
NodeMap(const Graph& graph, const _Value& value)
: Parent(graph, value) {}
@@ -628,7 +628,7 @@
typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
public:
- ArcMap(const Graph& graph)
+ explicit ArcMap(const Graph& graph)
: Parent(graph) {}
ArcMap(const Graph& graph, const _Value& value)
: Parent(graph, value) {}
@@ -652,7 +652,7 @@
typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
public:
- EdgeMap(const Graph& graph)
+ explicit EdgeMap(const Graph& graph)
: Parent(graph) {}
EdgeMap(const Graph& graph, const _Value& value)
diff -r e746fb14e680 -r 432c54cec63c lemon/bits/map_extender.h
--- a/lemon/bits/map_extender.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/bits/map_extender.h Thu Nov 05 08:39:49 2009 +0100
@@ -49,6 +49,8 @@
typedef typename Parent::Reference Reference;
typedef typename Parent::ConstReference ConstReference;
+ typedef typename Parent::ReferenceMapTag ReferenceMapTag;
+
class MapIt;
class ConstMapIt;
@@ -191,6 +193,8 @@
typedef typename Parent::Reference Reference;
typedef typename Parent::ConstReference ConstReference;
+ typedef typename Parent::ReferenceMapTag ReferenceMapTag;
+
class MapIt;
class ConstMapIt;
diff -r e746fb14e680 -r 432c54cec63c lemon/bucket_heap.h
--- a/lemon/bucket_heap.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/bucket_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -19,9 +19,9 @@
#ifndef LEMON_BUCKET_HEAP_H
#define LEMON_BUCKET_HEAP_H
-///\ingroup auxdat
+///\ingroup heaps
///\file
-///\brief Bucket Heap implementation.
+///\brief Bucket heap implementation.
#include <vector>
#include <utility>
@@ -53,35 +53,41 @@
}
- /// \ingroup auxdat
+ /// \ingroup heaps
///
- /// \brief A Bucket Heap implementation.
+ /// \brief Bucket heap data structure.
///
- /// 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.
+ /// 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.
///
- /// \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.
+ /// 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 <tt>[0..C)</tt>. So it should only be used when the
+ /// priorities are small. It is not intended to use as a Dijkstra heap.
+ ///
+ /// \tparam IM A read-writable item map with \c int values, used
+ /// internally to handle the cross references.
+ /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
+ /// The default is \e min-heap. If this parameter is set to \c false,
+ /// then the comparison is reversed, so the top(), prio() and pop()
+ /// functions deal with the item having maximum priority instead of the
+ /// minimum.
+ ///
+ /// \sa SimpleBucketHeap
template <typename IM, bool MIN = true>
class BucketHeap {
public:
- /// \e
- typedef typename IM::Key Item;
- /// \e
+
+ /// Type of the item-int map.
+ typedef IM ItemIntMap;
+ /// Type of the priorities.
typedef int Prio;
- /// \e
- typedef std::pair<Item, Prio> Pair;
- /// \e
- typedef IM ItemIntMap;
+ /// Type of the items stored in the heap.
+ typedef typename ItemIntMap::Key Item;
+ /// Type of the item-priority pairs.
+ typedef std::pair<Item,Prio> Pair;
private:
@@ -89,10 +95,10 @@
public:
- /// \brief Type to represent the items states.
+ /// \brief Type to represent the states of the items.
///
- /// 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
+ /// 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
@@ -104,37 +110,39 @@
};
public:
- /// \brief The constructor.
+
+ /// \brief 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.
+ /// 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 (<tt>-1</tt>) for each item.
explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
- /// The number of items stored in the heap.
+ /// \brief The number of items stored in the heap.
///
- /// \brief Returns 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 Checks if the heap stores no items.
+ /// \brief Check if the heap is empty.
///
- /// Returns \c true if and only if the heap stores no items.
+ /// This function returns \c true if the heap is empty.
bool empty() const { return _data.empty(); }
- /// \brief Make empty this heap.
+ /// \brief Make the heap empty.
///
- /// 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.
+ /// This functon makes the heap empty.
+ /// It does not change the cross reference map. If you want to reuse
+ /// a heap that is not surely empty, you should first clear it and
+ /// then you should set the cross reference map to \c PRE_HEAP
+ /// for each item.
void clear() {
_data.clear(); _first.clear(); _minimum = 0;
}
private:
- void relocate_last(int idx) {
+ void relocateLast(int idx) {
if (idx + 1 < int(_data.size())) {
_data[idx] = _data.back();
if (_data[idx].prev != -1) {
@@ -174,19 +182,24 @@
}
public:
+
/// \brief Insert a pair of item and priority into the heap.
///
- /// Adds \c p.first to the heap with priority \c p.second.
+ /// This function inserts \c p.first to the heap with priority
+ /// \c p.second.
/// \param p The pair to insert.
+ /// \pre \c p.first must not be stored in the heap.
void push(const Pair& p) {
push(p.first, p.second);
}
/// \brief Insert an item into the heap with the given priority.
///
- /// Adds \c i to the heap with priority \c p.
+ /// This function inserts the given item into the heap with the
+ /// given priority.
/// \param i The item to insert.
/// \param p The priority of the item.
+ /// \pre \e i must not be stored in the heap.
void push(const Item &i, const Prio &p) {
int idx = _data.size();
_iim[i] = idx;
@@ -197,10 +210,10 @@
}
}
- /// \brief Returns the item with minimum priority.
+ /// \brief Return the item having minimum priority.
///
- /// This method returns the item with minimum priority.
- /// \pre The heap must be nonempty.
+ /// This function returns the item having minimum priority.
+ /// \pre The heap must be non-empty.
Item top() const {
while (_first[_minimum] == -1) {
Direction::increase(_minimum);
@@ -208,10 +221,10 @@
return _data[_first[_minimum]].item;
}
- /// \brief Returns the minimum priority.
+ /// \brief The minimum priority.
///
- /// It returns the minimum priority.
- /// \pre The heap must be nonempty.
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
Prio prio() const {
while (_first[_minimum] == -1) {
Direction::increase(_minimum);
@@ -219,9 +232,9 @@
return _minimum;
}
- /// \brief Deletes the item with minimum priority.
+ /// \brief Remove the item having minimum priority.
///
- /// This method deletes the item with minimum priority from the heap.
+ /// This function removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {
while (_first[_minimum] == -1) {
@@ -230,37 +243,38 @@
int idx = _first[_minimum];
_iim[_data[idx].item] = -2;
unlace(idx);
- relocate_last(idx);
+ relocateLast(idx);
}
- /// \brief Deletes \c i from the heap.
+ /// \brief Remove the given item 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.
+ /// This function removes the given item from the heap if it is
+ /// already stored.
+ /// \param i The item to delete.
+ /// \pre \e i must be in the heap.
void erase(const Item &i) {
int idx = _iim[i];
_iim[_data[idx].item] = -2;
unlace(idx);
- relocate_last(idx);
+ relocateLast(idx);
}
-
- /// \brief Returns the priority of \c i.
+ /// \brief The priority of the given item.
///
- /// This function returns the priority of item \c i.
- /// \pre \c i must be in the heap.
+ /// This function returns the priority of the given item.
/// \param i The item.
+ /// \pre \e i must be in the heap.
Prio operator[](const Item &i) const {
int idx = _iim[i];
return _data[idx].value;
}
- /// \brief \c i gets to the heap with priority \c p independently
- /// if \c i was already there.
+ /// \brief Set the priority of an item or insert it, if it is
+ /// not stored in the heap.
///
- /// 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.
+ /// This method sets the priority of the given item if it is
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
/// \param i The item.
/// \param p The priority.
void set(const Item &i, const Prio &p) {
@@ -274,13 +288,12 @@
}
}
- /// \brief Decreases the priority of \c i to \c p.
+ /// \brief Decrease the priority of an item to the given value.
///
- /// 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.
+ /// This function decreases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
+ /// \pre \e i must be stored in the heap with priority at least \e p.
void decrease(const Item &i, const Prio &p) {
int idx = _iim[i];
unlace(idx);
@@ -291,13 +304,12 @@
lace(idx);
}
- /// \brief Increases the priority of \c i to \c p.
+ /// \brief Increase the priority of an item to the given value.
///
- /// 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.
+ /// This function increases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
+ /// \pre \e i must be stored in the heap with priority at most \e p.
void increase(const Item &i, const Prio &p) {
int idx = _iim[i];
unlace(idx);
@@ -305,13 +317,13 @@
lace(idx);
}
- /// \brief Returns if \c item is in, has already been in, or has
- /// never been in the heap.
+ /// \brief Return the state of an item.
///
- /// 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.
+ /// This method returns \c PRE_HEAP if the given item has never
+ /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+ /// and \c POST_HEAP otherwise.
+ /// In the latter case it is possible that the item will get back
+ /// to the heap again.
/// \param i The item.
State state(const Item &i) const {
int idx = _iim[i];
@@ -319,11 +331,11 @@
return State(idx);
}
- /// \brief Sets the state of the \c item in the heap.
+ /// \brief Set the state of an 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.
+ /// 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) {
@@ -359,33 +371,44 @@
}; // class BucketHeap
- /// \ingroup auxdat
+ /// \ingroup heaps
///
- /// \brief A Simplified Bucket Heap implementation.
+ /// \brief Simplified bucket heap data structure.
///
/// This class implements a simplified \e bucket \e heap data
- /// structure. It does not provide some functionality but it 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.
+ /// 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.
///
- /// \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.
+ /// Note that this implementation does not conform to the
+ /// \ref concepts::Heap "heap concept" due to the lack of some
+ /// functionality.
+ ///
+ /// \tparam IM A read-writable item map with \c int values, used
+ /// internally to handle the cross references.
+ /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
+ /// The default is \e min-heap. If this parameter is set to \c false,
+ /// then the comparison is reversed, so the top(), prio() and pop()
+ /// functions deal with the item having maximum priority instead of the
+ /// minimum.
///
/// \sa BucketHeap
template <typename IM, bool MIN = true >
class SimpleBucketHeap {
public:
- typedef typename IM::Key Item;
+
+ /// Type of the item-int map.
+ typedef IM ItemIntMap;
+ /// Type of the priorities.
typedef int Prio;
- typedef std::pair<Item, Prio> Pair;
- typedef IM ItemIntMap;
+ /// Type of the items stored in the heap.
+ typedef typename ItemIntMap::Key Item;
+ /// Type of the item-priority pairs.
+ typedef std::pair<Item,Prio> Pair;
private:
@@ -393,10 +416,10 @@
public:
- /// \brief Type to represent the items states.
+ /// \brief Type to represent the states of the items.
///
- /// 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
+ /// 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
@@ -409,48 +432,53 @@
public:
- /// \brief The constructor.
+ /// \brief 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.
+ /// 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 (<tt>-1</tt>) for each item.
explicit SimpleBucketHeap(ItemIntMap &map)
: _iim(map), _free(-1), _num(0), _minimum(0) {}
- /// \brief Returns the number of items stored in the heap.
+ /// \brief The number of items stored in the heap.
///
- /// The number of items stored in the heap.
+ /// This function returns the number of items stored in the heap.
int size() const { return _num; }
- /// \brief Checks if the heap stores no items.
+ /// \brief Check if the heap is empty.
///
- /// Returns \c true if and only if the heap stores no items.
+ /// This function returns \c true if the heap is empty.
bool empty() const { return _num == 0; }
- /// \brief Make empty this heap.
+ /// \brief Make the heap empty.
///
- /// 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.
+ /// This functon makes the heap empty.
+ /// It does not change the cross reference map. If you want to reuse
+ /// a heap that is not surely empty, you should first clear it and
+ /// then you should set the cross reference map to \c PRE_HEAP
+ /// for each item.
void clear() {
_data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
}
/// \brief Insert a pair of item and priority into the heap.
///
- /// Adds \c p.first to the heap with priority \c p.second.
+ /// This function inserts \c p.first to the heap with priority
+ /// \c p.second.
/// \param p The pair to insert.
+ /// \pre \c p.first must not be stored in the heap.
void push(const Pair& p) {
push(p.first, p.second);
}
/// \brief Insert an item into the heap with the given priority.
///
- /// Adds \c i to the heap with priority \c p.
+ /// This function inserts the given item into the heap with the
+ /// given priority.
/// \param i The item to insert.
/// \param p The priority of the item.
+ /// \pre \e i must not be stored in the heap.
void push(const Item &i, const Prio &p) {
int idx;
if (_free == -1) {
@@ -471,10 +499,10 @@
++_num;
}
- /// \brief Returns the item with minimum priority.
+ /// \brief Return the item having minimum priority.
///
- /// This method returns the item with minimum priority.
- /// \pre The heap must be nonempty.
+ /// This function returns the item having minimum priority.
+ /// \pre The heap must be non-empty.
Item top() const {
while (_first[_minimum] == -1) {
Direction::increase(_minimum);
@@ -482,10 +510,10 @@
return _data[_first[_minimum]].item;
}
- /// \brief Returns the minimum priority.
+ /// \brief The minimum priority.
///
- /// It returns the minimum priority.
- /// \pre The heap must be nonempty.
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
Prio prio() const {
while (_first[_minimum] == -1) {
Direction::increase(_minimum);
@@ -493,9 +521,9 @@
return _minimum;
}
- /// \brief Deletes the item with minimum priority.
+ /// \brief Remove the item having minimum priority.
///
- /// This method deletes the item with minimum priority from the heap.
+ /// This function removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {
while (_first[_minimum] == -1) {
@@ -509,16 +537,15 @@
--_num;
}
- /// \brief Returns the priority of \c i.
+ /// \brief The priority of the given item.
///
- /// 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.
+ /// This function returns the priority of the given item.
/// \param i The item.
+ /// \pre \e i must be in the heap.
+ /// \warning This operator is not a constant time function because
+ /// it scans the whole data structure to find the proper value.
Prio operator[](const Item &i) const {
- for (int k = 0; k < _first.size(); ++k) {
+ for (int k = 0; k < int(_first.size()); ++k) {
int idx = _first[k];
while (idx != -1) {
if (_data[idx].item == i) {
@@ -530,13 +557,13 @@
return -1;
}
- /// \brief Returns if \c item is in, has already been in, or has
- /// never been in the heap.
+ /// \brief Return the state of an item.
///
- /// 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.
+ /// This method returns \c PRE_HEAP if the given item has never
+ /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+ /// and \c POST_HEAP otherwise.
+ /// In the latter case it is possible that the item will get back
+ /// to the heap again.
/// \param i The item.
State state(const Item &i) const {
int idx = _iim[i];
diff -r e746fb14e680 -r 432c54cec63c lemon/cbc.cc
--- a/lemon/cbc.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/cbc.cc Thu Nov 05 08:39:49 2009 +0100
@@ -94,6 +94,18 @@
return _prob->numberRows() - 1;
}
+ int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
+ std::vector<int> indexes;
+ std::vector<Value> 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) {
_prob->deleteColumn(i);
diff -r e746fb14e680 -r 432c54cec63c lemon/cbc.h
--- a/lemon/cbc.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/cbc.h Thu Nov 05 08:39:49 2009 +0100
@@ -62,6 +62,7 @@
virtual int _addCol();
virtual int _addRow();
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
virtual void _eraseRow(int i);
diff -r e746fb14e680 -r 432c54cec63c lemon/circulation.h
--- a/lemon/circulation.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/circulation.h Thu Nov 05 08:39:49 2009 +0100
@@ -72,7 +72,11 @@
/// The type of the map that stores the flow values.
/// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
/// concept.
+#ifdef DOXYGEN
+ typedef GR::ArcMap<Value> FlowMap;
+#else
typedef typename Digraph::template ArcMap<Value> FlowMap;
+#endif
/// \brief Instantiates a FlowMap.
///
@@ -87,9 +91,12 @@
///
/// The elevator type used by the algorithm.
///
- /// \sa Elevator
- /// \sa LinkedElevator
+ /// \sa Elevator, LinkedElevator
+#ifdef DOXYGEN
+ typedef lemon::Elevator<GR, GR::Node> Elevator;
+#else
typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
+#endif
/// \brief Instantiates an Elevator.
///
@@ -450,25 +457,27 @@
return *_level;
}
- /// \brief Sets the tolerance used by algorithm.
+ /// \brief Sets the tolerance used by the algorithm.
///
- /// Sets the tolerance used by algorithm.
- Circulation& tolerance(const Tolerance& tolerance) const {
+ /// Sets the tolerance object used by the algorithm.
+ /// \return <tt>(*this)</tt>
+ Circulation& tolerance(const Tolerance& tolerance) {
_tol = tolerance;
return *this;
}
/// \brief Returns a const reference to the tolerance.
///
- /// Returns a const reference to the tolerance.
+ /// Returns a const reference to the tolerance object used by
+ /// the algorithm.
const Tolerance& tolerance() const {
- return tolerance;
+ return _tol;
}
/// \name Execution Control
/// The simplest way to execute the algorithm is to call \ref run().\n
- /// If you need more control on the initial solution or the execution,
- /// first you have to call one of the \ref init() functions, then
+ /// If you need better control on the initial solution or the execution,
+ /// you have to call one of the \ref init() functions first, then
/// the \ref start() function.
///@{
diff -r e746fb14e680 -r 432c54cec63c lemon/clp.cc
--- a/lemon/clp.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/clp.cc Thu Nov 05 08:39:49 2009 +0100
@@ -78,6 +78,19 @@
return _prob->numberRows() - 1;
}
+ int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
+ std::vector<int> indexes;
+ std::vector<Value> 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) {
_col_names_ref.erase(_prob->getColumnName(c));
diff -r e746fb14e680 -r 432c54cec63c lemon/clp.h
--- a/lemon/clp.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/clp.h Thu Nov 05 08:39:49 2009 +0100
@@ -75,6 +75,7 @@
virtual int _addCol();
virtual int _addRow();
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
virtual void _eraseRow(int i);
diff -r e746fb14e680 -r 432c54cec63c lemon/concepts/digraph.h
--- a/lemon/concepts/digraph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/concepts/digraph.h Thu Nov 05 08:39:49 2009 +0100
@@ -35,46 +35,40 @@
///
/// \brief Class describing the concept of directed graphs.
///
- /// This class describes the \ref concept "concept" of the
- /// immutable directed digraphs.
+ /// This class describes the common interface of all directed
+ /// graphs (digraphs).
///
- /// Note that actual digraph implementation like @ref ListDigraph or
- /// @ref SmartDigraph may have several additional functionality.
+ /// 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.
///
- /// \sa concept
+ /// \sa Graph
class Digraph {
private:
- ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+ /// 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.
+ void operator=(const Digraph &) {}
- ///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.
+ public:
+ /// Default constructor.
+ Digraph() { }
- ///Assignment of \ref Digraph "Digraph"s to another ones are
- ///\e not allowed. Use DigraphCopy() instead.
-
- void operator=(const Digraph &) {}
- public:
- ///\e
-
- /// Defalult constructor.
-
- /// Defalult constructor.
- ///
- Digraph() { }
- /// Class for identifying a node of the digraph
+ /// The node type of the digraph
/// This class identifies a node of the digraph. It also serves
/// as a base class of the node iterators,
- /// thus they will convert to this type.
+ /// thus they convert to this type.
class Node {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the object to an undefined value.
Node() { }
/// Copy constructor.
@@ -82,40 +76,39 @@
///
Node(const Node&) { }
- /// Invalid constructor \& conversion.
+ /// %Invalid constructor \& conversion.
- /// This constructor initializes the iterator to be invalid.
+ /// Initializes the object 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 invalid.
+ /// same object or both are \c INVALID.
bool operator==(Node) const { return true; }
/// Inequality operator
- /// \sa operator==(Node n)
- ///
+ /// Inequality operator.
bool operator!=(Node) const { return true; }
/// Artificial ordering operator.
- /// To allow the use of digraph descriptors as key type in std::map or
- /// similar associative container we require this.
+ /// Artificial ordering operator.
///
- /// \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.
+ /// \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.
bool operator<(Node) const { return false; }
-
};
- /// This iterator goes through each node.
+ /// Iterator class for the nodes.
- /// This iterator goes through each node.
+ /// This iterator goes through each node of the digraph.
/// Its usage is quite simple, for example you can count the number
- /// of nodes in digraph \c g of type \c Digraph like this:
+ /// of nodes in a digraph \c g of type \c %Digraph like this:
///\code
/// int count=0;
/// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count;
@@ -124,30 +117,28 @@
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
NodeIt() { }
/// Copy constructor.
/// Copy constructor.
///
NodeIt(const NodeIt& n) : Node(n) { }
- /// Invalid constructor \& conversion.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes 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 \c g.
+ /// Sets the iterator to the first node of the given digraph.
///
- NodeIt(const Digraph&) { }
- /// Node -> NodeIt conversion.
+ explicit NodeIt(const Digraph&) { }
+ /// Sets the iterator to the given node.
- /// 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.
+ /// Sets the iterator to the given node of the given digraph.
+ ///
NodeIt(const Digraph&, const Node&) { }
/// Next node.
@@ -157,7 +148,7 @@
};
- /// Class for identifying an arc of the digraph
+ /// The arc type of the digraph
/// This class identifies an arc of the digraph. It also serves
/// as a base class of the arc iterators,
@@ -166,207 +157,214 @@
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the object to an undefined value.
Arc() { }
/// Copy constructor.
/// Copy constructor.
///
Arc(const Arc&) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
- ///
+ /// Initializes the object to be invalid.
+ /// \sa Invalid for more details.
Arc(Invalid) { }
/// Equality operator
+ /// Equality operator.
+ ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are invalid.
+ /// same object or both are \c INVALID.
bool operator==(Arc) const { return true; }
/// Inequality operator
- /// \sa operator==(Arc n)
- ///
+ /// Inequality operator.
bool operator!=(Arc) const { return true; }
/// Artificial ordering operator.
- /// To allow the use of digraph descriptors as key type in std::map or
- /// similar associative container we require this.
+ /// Artificial ordering operator.
///
- /// \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.
+ /// \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.
bool operator<(Arc) const { return false; }
};
- /// This iterator goes trough the outgoing arcs of a node.
+ /// Iterator class for the outgoing arcs of a node.
/// This iterator goes trough the \e outgoing arcs of a certain node
/// of a digraph.
/// Its usage is quite simple, for example you can count the number
/// of outgoing arcs of a node \c n
- /// in digraph \c g of type \c Digraph as follows.
+ /// in a digraph \c g of type \c %Digraph as follows.
///\code
/// int count=0;
- /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
+ /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
///\endcode
-
class OutArcIt : public Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
OutArcIt() { }
/// Copy constructor.
/// Copy constructor.
///
OutArcIt(const OutArcIt& e) : Arc(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ OutArcIt(Invalid) { }
+ /// Sets the iterator to the first outgoing arc.
+
+ /// Sets the iterator to the first outgoing arc of the given node.
///
- OutArcIt(Invalid) { }
- /// This constructor sets the iterator to the first outgoing arc.
+ OutArcIt(const Digraph&, const Node&) { }
+ /// Sets the iterator to the given arc.
- /// This constructor sets the iterator to the first outgoing arc of
- /// the node.
- OutArcIt(const Digraph&, const Node&) { }
- /// 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.
+ /// Sets the iterator to the given arc of the given digraph.
+ ///
OutArcIt(const Digraph&, const Arc&) { }
- ///Next outgoing arc
+ /// Next outgoing arc
/// Assign the iterator to the next
/// outgoing arc of the corresponding node.
OutArcIt& operator++() { return *this; }
};
- /// This iterator goes trough the incoming arcs of a node.
+ /// Iterator class for 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 outgoing arcs of a node \c n
- /// in digraph \c g of type \c Digraph as follows.
+ /// of incoming arcs of a node \c n
+ /// in a digraph \c g of type \c %Digraph as follows.
///\code
/// int count=0;
- /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
+ /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
///\endcode
-
class InArcIt : public Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
InArcIt() { }
/// Copy constructor.
/// Copy constructor.
///
InArcIt(const InArcIt& e) : Arc(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ InArcIt(Invalid) { }
+ /// Sets the iterator to the first incoming arc.
+
+ /// Sets the iterator to the first incoming arc of the given node.
///
- InArcIt(Invalid) { }
- /// This constructor sets the iterator to first incoming arc.
+ InArcIt(const Digraph&, const Node&) { }
+ /// Sets the iterator to the given arc.
- /// This constructor set the iterator to the first incoming arc of
- /// the node.
- InArcIt(const Digraph&, const Node&) { }
- /// 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.
+ /// Sets the iterator to the given arc of the given digraph.
+ ///
InArcIt(const Digraph&, const Arc&) { }
/// Next incoming arc
- /// Assign the iterator to the next inarc of the corresponding node.
- ///
+ /// Assign the iterator to the next
+ /// incoming arc of the corresponding node.
InArcIt& operator++() { return *this; }
};
- /// This iterator goes through each arc.
- /// This iterator goes through each arc of a digraph.
+ /// Iterator class for the arcs.
+
+ /// This iterator goes through each arc of the 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 e(g); e!=INVALID; ++e) ++count;
+ /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
///\endcode
class ArcIt : public Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
ArcIt() { }
/// Copy constructor.
/// Copy constructor.
///
ArcIt(const ArcIt& e) : Arc(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ ArcIt(Invalid) { }
+ /// Sets the iterator to the first arc.
+
+ /// Sets the iterator to the first arc of the given digraph.
///
- ArcIt(Invalid) { }
- /// This constructor sets the iterator to the first arc.
+ explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
+ /// Sets the iterator to the given 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.
+ /// Sets the iterator to the given arc of the given digraph.
+ ///
ArcIt(const Digraph&, const Arc&) { }
- ///Next arc
+ /// Next arc
/// Assign the iterator to the next arc.
+ ///
ArcIt& operator++() { return *this; }
};
- ///Gives back the target node of an arc.
- ///Gives back the target node of an arc.
+ /// \brief The source node of the arc.
///
- Node target(Arc) const { return INVALID; }
- ///Gives back the source node of an arc.
-
- ///Gives back the source node of an arc.
- ///
+ /// Returns the source node of the given arc.
Node source(Arc) const { return INVALID; }
- /// \brief Returns the ID of the node.
+ /// \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.
int id(Node) const { return -1; }
- /// \brief Returns the ID of the arc.
+ /// \brief The ID of the arc.
+ ///
+ /// Returns the ID of the given arc.
int id(Arc) const { return -1; }
- /// \brief Returns the node with the given ID.
+ /// \brief The node with the given ID.
///
- /// \pre The argument should be a valid node ID in the graph.
+ /// Returns the node with the given ID.
+ /// \pre The argument should be a valid node ID in the digraph.
Node nodeFromId(int) const { return INVALID; }
- /// \brief Returns the arc with the given ID.
+ /// \brief The arc with the given ID.
///
- /// \pre The argument should be a valid arc ID in the graph.
+ /// Returns the arc with the given ID.
+ /// \pre The argument should be a valid arc ID in the digraph.
Arc arcFromId(int) const { return INVALID; }
- /// \brief Returns an upper bound on the node IDs.
+ /// \brief An upper bound on the node IDs.
+ ///
+ /// Returns an upper bound on the node IDs.
int maxNodeId() const { return -1; }
- /// \brief Returns an upper bound on the arc IDs.
+ /// \brief An upper bound on the arc IDs.
+ ///
+ /// Returns an upper bound on the arc IDs.
int maxArcId() const { return -1; }
void first(Node&) const {}
@@ -392,45 +390,46 @@
// Dummy parameter.
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.
///
- /// Gives back the base node of the iterator.
- /// It is always the target of the pointed arc.
- Node baseNode(const InArcIt&) const { return INVALID; }
+ /// 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.
///
- /// Gives back the running node of the iterator.
- /// It is always the source of the pointed arc.
- Node runningNode(const InArcIt&) const { return INVALID; }
+ /// 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.
///
- /// Gives back the base node of the iterator.
- /// It is always the source of the pointed arc.
- Node baseNode(const OutArcIt&) const { return INVALID; }
+ /// 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.
///
- /// Gives back the running node of the iterator.
- /// It is always the target of the pointed arc.
- Node runningNode(const OutArcIt&) const { return INVALID; }
+ /// 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 The opposite node on the given arc.
+ /// \brief Standard graph map type for the nodes.
///
- /// 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.
+ /// Standard graph map type for the nodes.
+ /// It conforms to the ReferenceMap concept.
template<class T>
class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
public:
- ///\e
- NodeMap(const Digraph&) { }
- ///\e
+ /// Constructor
+ explicit NodeMap(const Digraph&) { }
+ /// Constructor with given initial value
NodeMap(const Digraph&, T) { }
private:
@@ -445,17 +444,19 @@
}
};
- /// \brief Reference map of the arcs to type \c T.
+ /// \brief Standard graph map type for the arcs.
///
- /// Reference map of the arcs to type \c T.
+ /// Standard graph map type for the arcs.
+ /// It conforms to the ReferenceMap concept.
template<class T>
class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
public:
- ///\e
- ArcMap(const Digraph&) { }
- ///\e
+ /// Constructor
+ explicit ArcMap(const Digraph&) { }
+ /// Constructor with given initial value
ArcMap(const Digraph&, T) { }
+
private:
///Copy constructor
ArcMap(const ArcMap& em) :
diff -r e746fb14e680 -r 432c54cec63c lemon/concepts/graph.h
--- a/lemon/concepts/graph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/concepts/graph.h Thu Nov 05 08:39:49 2009 +0100
@@ -18,12 +18,14 @@
///\ingroup graph_concepts
///\file
-///\brief The concept of Undirected Graphs.
+///\brief The concept of undirected graphs.
#ifndef LEMON_CONCEPTS_GRAPH_H
#define LEMON_CONCEPTS_GRAPH_H
#include <lemon/concepts/graph_components.h>
+#include <lemon/concepts/maps.h>
+#include <lemon/concept_check.h>
#include <lemon/core.h>
namespace lemon {
@@ -31,63 +33,74 @@
/// \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.
///
- /// 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
+ /// 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
/// run properly, of course.
+ /// An actual graph implementation like \ref ListGraph or
+ /// \ref SmartGraph may have additional functionality.
///
- /// 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.
+ /// 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.
///
- /// 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.
+ /// 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.
///
- /// 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.
+ /// 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
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:
- /// \brief The undirected graph should be tagged by the
- /// UndirectedTag.
+ /// Default constructor.
+ Graph() {}
+
+ /// \brief Undirected graphs should be tagged with \c UndirectedTag.
///
- /// The undirected graph should be tagged by the UndirectedTag. This
- /// tag helps the enable_if technics to make compile time
+ /// Undirected graphs should be tagged with \c UndirectedTag.
+ ///
+ /// This tag helps the \c enable_if technics to make compile time
/// specializations for undirected graphs.
typedef True UndirectedTag;
- /// \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.
+ /// 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.
class Node {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the object to an undefined value.
Node() { }
/// Copy constructor.
@@ -95,40 +108,40 @@
///
Node(const Node&) { }
- /// Invalid constructor \& conversion.
+ /// %Invalid constructor \& conversion.
- /// This constructor initializes the iterator to be invalid.
+ /// Initializes the object 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 invalid.
+ /// same object or both are \c INVALID.
bool operator==(Node) const { return true; }
/// Inequality operator
- /// \sa operator==(Node n)
- ///
+ /// Inequality operator.
bool operator!=(Node) const { return true; }
/// Artificial ordering operator.
- /// To allow the use of graph descriptors as key type in std::map or
- /// similar associative container we require this.
+ /// Artificial ordering operator.
///
- /// \note This operator only have to define some strict ordering of
+ /// \note This operator only has 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; }
};
- /// This iterator goes through each node.
+ /// Iterator class for the nodes.
- /// This iterator goes through each node.
+ /// This iterator goes through each node of the graph.
/// Its usage is quite simple, for example you can count the number
- /// of nodes in graph \c g of type \c Graph like this:
+ /// of nodes in a graph \c g of type \c %Graph like this:
///\code
/// int count=0;
/// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
@@ -137,30 +150,28 @@
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
NodeIt() { }
/// Copy constructor.
/// Copy constructor.
///
NodeIt(const NodeIt& n) : Node(n) { }
- /// Invalid constructor \& conversion.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes 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 \c g.
+ /// Sets the iterator to the first node of the given digraph.
///
- NodeIt(const Graph&) { }
- /// Node -> NodeIt conversion.
+ explicit NodeIt(const Graph&) { }
+ /// Sets the iterator to the given node.
- /// 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.
+ /// Sets the iterator to the given node of the given digraph.
+ ///
NodeIt(const Graph&, const Node&) { }
/// Next node.
@@ -170,54 +181,55 @@
};
- /// The base type of the edge iterators.
+ /// The edge type of the graph
- /// The base type of the edge iterators.
- ///
+ /// 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.
class Edge {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the object to an undefined value.
Edge() { }
/// Copy constructor.
/// Copy constructor.
///
Edge(const Edge&) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
- ///
+ /// Initializes the object to be invalid.
+ /// \sa Invalid for more details.
Edge(Invalid) { }
/// Equality operator
+ /// Equality operator.
+ ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are invalid.
+ /// same object or both are \c INVALID.
bool operator==(Edge) const { return true; }
/// Inequality operator
- /// \sa operator==(Edge n)
- ///
+ /// Inequality operator.
bool operator!=(Edge) const { return true; }
/// Artificial ordering operator.
- /// To allow the use of graph descriptors as key type in std::map or
- /// similar associative container we require this.
+ /// Artificial ordering operator.
///
- /// \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.
+ /// \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.
bool operator<(Edge) const { return false; }
};
- /// This iterator goes through each edge.
+ /// Iterator class for the edges.
- /// This iterator goes through each edge of a graph.
+ /// This iterator goes through each edge of the 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;
/// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
@@ -226,290 +238,285 @@
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
EdgeIt() { }
/// Copy constructor.
/// Copy constructor.
///
EdgeIt(const EdgeIt& e) : Edge(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ EdgeIt(Invalid) { }
+ /// Sets the iterator to the first edge.
+
+ /// Sets the iterator to the first edge of the given graph.
///
- EdgeIt(Invalid) { }
- /// This constructor sets the iterator to the first edge.
+ explicit EdgeIt(const Graph&) { }
+ /// Sets the iterator to the given 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.
+ /// Sets the iterator to the given edge of the given graph.
+ ///
EdgeIt(const Graph&, const Edge&) { }
/// Next edge
/// Assign the iterator to the next edge.
+ ///
EdgeIt& operator++() { return *this; }
};
- /// \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.
- ///
+ /// Iterator class for the incident edges of a node.
+
+ /// This iterator goes trough the incident undirected edges
+ /// of a certain node of a graph.
/// Its usage is quite simple, for example you can compute the
- /// degree (i.e. count the number of incident arcs of a node \c n
- /// in graph \c g of type \c Graph as follows.
+ /// degree (i.e. the number of incident edges) of a node \c n
+ /// in a graph \c g of type \c %Graph as follows.
///
///\code
/// int count=0;
/// 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
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
IncEdgeIt() { }
/// Copy constructor.
/// Copy constructor.
///
IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ IncEdgeIt(Invalid) { }
+ /// Sets the iterator to the first incident edge.
+
+ /// Sets the iterator to the first incident edge of the given node.
///
- IncEdgeIt(Invalid) { }
- /// This constructor sets the iterator to first incident arc.
+ IncEdgeIt(const Graph&, const Node&) { }
+ /// Sets the iterator to the given edge.
- /// This constructor set the iterator to the first incident arc of
- /// the node.
- IncEdgeIt(const Graph&, const Node&) { }
- /// Edge -> IncEdgeIt conversion
+ /// Sets the iterator to the given edge of the given graph.
+ ///
+ IncEdgeIt(const Graph&, const Edge&) { }
+ /// Next incident edge
- /// 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 arc
-
- /// Assign the iterator to the next incident arc
+ /// Assign the iterator to the next incident edge
/// of the corresponding node.
IncEdgeIt& operator++() { return *this; }
};
- /// The directed arc type.
+ /// The arc type of the graph
- /// The directed arc type. It can be converted to the
- /// edge or it should be inherited from the undirected
- /// edge.
+ /// 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.
class Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the object to an undefined value.
Arc() { }
/// Copy constructor.
/// Copy constructor.
///
Arc(const Arc&) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
- ///
+ /// Initializes the object to be invalid.
+ /// \sa Invalid for more details.
Arc(Invalid) { }
/// Equality operator
+ /// Equality operator.
+ ///
/// Two iterators are equal if and only if they point to the
- /// same object or both are invalid.
+ /// same object or both are \c INVALID.
bool operator==(Arc) const { return true; }
/// Inequality operator
- /// \sa operator==(Arc n)
- ///
+ /// Inequality operator.
bool operator!=(Arc) const { return true; }
/// Artificial ordering operator.
- /// To allow the use of graph descriptors as key type in std::map or
- /// similar associative container we require this.
+ /// Artificial ordering operator.
///
- /// \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.
+ /// \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.
bool operator<(Arc) const { return false; }
- /// Converison to Edge
+ /// Converison to \c Edge
+
+ /// Converison to \c Edge.
+ ///
operator Edge() const { return Edge(); }
};
- /// This iterator goes through each directed arc.
- /// This iterator goes through each arc of a graph.
+ /// Iterator class for the arcs.
+
+ /// This iterator goes through each directed arc of the 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 e(g); e!=INVALID; ++e) ++count;
+ /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
///\endcode
class ArcIt : public Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
ArcIt() { }
/// Copy constructor.
/// Copy constructor.
///
ArcIt(const ArcIt& e) : Arc(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ ArcIt(Invalid) { }
+ /// Sets the iterator to the first arc.
+
+ /// Sets the iterator to the first arc of the given graph.
///
- ArcIt(Invalid) { }
- /// This constructor sets the iterator to the first arc.
+ explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
+ /// Sets the iterator to the given 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.
+ /// Sets the iterator to the given arc of the given graph.
+ ///
ArcIt(const Graph&, const Arc&) { }
- ///Next arc
+ /// Next arc
/// Assign the iterator to the next arc.
+ ///
ArcIt& operator++() { return *this; }
};
- /// This iterator goes trough the outgoing directed arcs of a node.
+ /// Iterator class for the outgoing arcs of a node.
- /// This iterator goes trough the \e outgoing arcs of a certain node
- /// of a graph.
+ /// This iterator goes trough the \e outgoing directed 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 graph \c g of type \c Graph as follows.
+ /// in a graph \c g of type \c %Graph as follows.
///\code
/// int count=0;
- /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
+ /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
///\endcode
-
class OutArcIt : public Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
OutArcIt() { }
/// Copy constructor.
/// Copy constructor.
///
OutArcIt(const OutArcIt& e) : Arc(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ OutArcIt(Invalid) { }
+ /// Sets the iterator to the first outgoing arc.
+
+ /// Sets the iterator to the first outgoing arc of the given node.
///
- OutArcIt(Invalid) { }
- /// 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);
}
- /// Arc -> OutArcIt conversion
+ /// Sets the iterator to the given arc.
- /// 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.
+ /// Sets the iterator to the given arc of the given graph.
+ ///
OutArcIt(const Graph&, const Arc&) { }
- ///Next outgoing arc
+ /// Next outgoing arc
/// Assign the iterator to the next
/// outgoing arc of the corresponding node.
OutArcIt& operator++() { return *this; }
};
- /// This iterator goes trough the incoming directed arcs of a node.
+ /// Iterator class for the incoming arcs of a node.
- /// This iterator goes trough the \e incoming arcs of a certain node
- /// of a graph.
+ /// This iterator goes trough the \e incoming directed 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 graph \c g of type \c Graph as follows.
+ /// of incoming arcs of a node \c n
+ /// in a graph \c g of type \c %Graph as follows.
///\code
/// int count=0;
- /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
+ /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
///\endcode
-
class InArcIt : public Arc {
public:
/// Default constructor
- /// @warning The default constructor sets the iterator
- /// to an undefined value.
+ /// Default constructor.
+ /// \warning It sets the iterator to an undefined value.
InArcIt() { }
/// Copy constructor.
/// Copy constructor.
///
InArcIt(const InArcIt& e) : Arc(e) { }
- /// Initialize the iterator to be invalid.
+ /// %Invalid constructor \& conversion.
- /// Initialize the iterator to be invalid.
+ /// Initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ InArcIt(Invalid) { }
+ /// Sets the iterator to the first incoming arc.
+
+ /// Sets the iterator to the first incoming arc of the given node.
///
- InArcIt(Invalid) { }
- /// 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);
}
- /// Arc -> InArcIt conversion
+ /// Sets the iterator to the given arc.
- /// 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.
+ /// Sets the iterator to the given arc of the given graph.
+ ///
InArcIt(const Graph&, const Arc&) { }
/// Next incoming arc
- /// Assign the iterator to the next inarc of the corresponding node.
- ///
+ /// Assign the iterator to the next
+ /// incoming arc of the corresponding node.
InArcIt& operator++() { return *this; }
};
- /// \brief Reference map of the nodes to type \c T.
+ /// \brief Standard graph map type for the nodes.
///
- /// Reference map of the nodes to type \c T.
+ /// Standard graph map type for the nodes.
+ /// It conforms to the ReferenceMap concept.
template<class T>
class NodeMap : public ReferenceMap<Node, T, T&, const T&>
{
public:
- ///\e
- NodeMap(const Graph&) { }
- ///\e
+ /// Constructor
+ explicit NodeMap(const Graph&) { }
+ /// Constructor with given initial value
NodeMap(const Graph&, T) { }
private:
@@ -524,18 +531,20 @@
}
};
- /// \brief Reference map of the arcs to type \c T.
+ /// \brief Standard graph map type for the arcs.
///
- /// Reference map of the arcs to type \c T.
+ /// Standard graph map type for the arcs.
+ /// It conforms to the ReferenceMap concept.
template<class T>
class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
{
public:
- ///\e
- ArcMap(const Graph&) { }
- ///\e
+ /// Constructor
+ explicit ArcMap(const Graph&) { }
+ /// Constructor with given initial value
ArcMap(const Graph&, T) { }
+
private:
///Copy constructor
ArcMap(const ArcMap& em) :
@@ -548,18 +557,20 @@
}
};
- /// Reference map of the edges to type \c T.
-
- /// Reference map of the edges to type \c T.
+ /// \brief Standard graph map type for the edges.
+ ///
+ /// Standard graph map type for the edges.
+ /// It conforms to the ReferenceMap concept.
template<class T>
class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
{
public:
- ///\e
- EdgeMap(const Graph&) { }
- ///\e
+ /// Constructor
+ explicit EdgeMap(const Graph&) { }
+ /// Constructor with given initial value
EdgeMap(const Graph&, T) { }
+
private:
///Copy constructor
EdgeMap(const EdgeMap& em) :
@@ -572,107 +583,124 @@
}
};
- /// \brief Direct the given edge.
+ /// \brief The first node of the 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.
+ /// Returns the first node of 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.
+ /// 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.
/// \sa v()
/// \sa direction()
Node u(Edge) const { return INVALID; }
- /// \brief Second node of the edge.
+ /// \brief The second node of the edge.
///
- /// \return The second node of the given edge.
+ /// Returns 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.
+ /// 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.
/// \sa u()
/// \sa direction()
Node v(Edge) const { return INVALID; }
- /// \brief Source node of the directed arc.
+ /// \brief The source node of the arc.
+ ///
+ /// Returns the source node of the given arc.
Node source(Arc) const { return INVALID; }
- /// \brief Target node of the directed arc.
+ /// \brief The target node of the arc.
+ ///
+ /// Returns the target node of the given arc.
Node target(Arc) const { return INVALID; }
- /// \brief Returns the id of the node.
+ /// \brief The ID of the node.
+ ///
+ /// Returns the ID of the given node.
int id(Node) const { return -1; }
- /// \brief Returns the id of the edge.
+ /// \brief The ID of the edge.
+ ///
+ /// Returns the ID of the given edge.
int id(Edge) const { return -1; }
- /// \brief Returns the id of the arc.
+ /// \brief The ID of the arc.
+ ///
+ /// Returns the ID of the given arc.
int id(Arc) const { return -1; }
- /// \brief Returns the node with the given id.
+ /// \brief The node with the given ID.
///
- /// \pre The argument should be a valid node id in the graph.
+ /// 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 Returns the edge with the given id.
+ /// \brief The edge with the given ID.
///
- /// \pre The argument should be a valid edge id in the graph.
+ /// 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 Returns the arc with the given id.
+ /// \brief The arc with the given ID.
///
- /// \pre The argument should be a valid arc id in the graph.
+ /// 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 Returns an upper bound on the node IDs.
+ /// \brief An upper bound on the node IDs.
+ ///
+ /// Returns an upper bound on the node IDs.
int maxNodeId() const { return -1; }
- /// \brief Returns an upper bound on the edge IDs.
+ /// \brief An upper bound on the edge IDs.
+ ///
+ /// Returns an upper bound on the edge IDs.
int maxEdgeId() const { return -1; }
- /// \brief Returns an upper bound on the arc IDs.
+ /// \brief An upper bound on the arc IDs.
+ ///
+ /// 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 {}
void next(Node&) const {}
@@ -705,47 +733,39 @@
// Dummy parameter.
int maxId(Arc) const { return -1; }
- /// \brief Base node of the iterator
+ /// \brief The 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 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 (the target in this case) of the
- /// iterator
- Node runningNode(OutArcIt e) const {
- return target(e);
- }
+ /// Returns the running node of the given incident edge iterator.
+ Node runningNode(IncEdgeIt) const { return INVALID; }
- /// \brief Base node of the iterator
+ /// \brief The 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 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 (the source in this case) of the
- /// iterator
- Node runningNode(InArcIt e) const {
- return source(e);
- }
+ /// 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 Base node of the iterator
+ /// \brief The base node of the iterator.
///
- /// Returns the base node of the iterator
- Node baseNode(IncEdgeIt) const {
- return INVALID;
- }
+ /// 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 Running node of the iterator
+ /// \brief The running node of the iterator.
///
- /// Returns the running node of the iterator
- Node runningNode(IncEdgeIt) const {
- return INVALID;
- }
+ /// 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; }
template <typename _Graph>
struct Constraints {
diff -r e746fb14e680 -r 432c54cec63c lemon/concepts/graph_components.h
--- a/lemon/concepts/graph_components.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/concepts/graph_components.h Thu Nov 05 08:39:49 2009 +0100
@@ -92,7 +92,7 @@
/// It makes possible to use graph item types as key types in
/// associative containers (e.g. \c std::map).
///
- /// \note This operator only have to define some strict ordering of
+ /// \note This operator only has to define some strict ordering of
/// the items; this order has nothing to do with the iteration
/// ordering of the items.
bool operator<(const GraphItem&) const { return false; }
diff -r e746fb14e680 -r 432c54cec63c lemon/concepts/heap.h
--- a/lemon/concepts/heap.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/concepts/heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -16,13 +16,13 @@
*
*/
+#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 <lemon/core.h>
#include <lemon/concept_check.h>
@@ -35,21 +35,27 @@
/// \brief The heap concept.
///
- /// 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.
+ /// 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.
///
- /// \tparam PR Type of the priority of the items.
- /// \tparam IM A read and writable item map with int values, used
+ /// 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
/// internally to handle the cross references.
- /// \tparam Comp A functor class for the ordering of the priorities.
+ /// \tparam CMP A functor class for comparing the priorities.
/// The default is \c std::less<PR>.
#ifdef DOXYGEN
- template <typename PR, typename IM, typename Comp = std::less<PR> >
+ template <typename PR, typename IM, typename CMP>
#else
- template <typename PR, typename IM>
+ template <typename PR, typename IM, typename CMP = std::less<PR> >
#endif
class Heap {
public:
@@ -64,109 +70,125 @@
/// \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 later two are indifferent
- /// from the point of view of the heap, but may be useful for
- /// the user.
+ /// "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 (<tt>-1</tt>) to any element to be put in the heap.
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 The constructor.
+ /// \brief Constructor.
///
- /// The 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 (<tt>-1</tt>) for every item.
+ /// \c PRE_HEAP (<tt>-1</tt>) for each 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 (<tt>-1</tt>) 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.
///
- /// Returns the number of items stored in the heap.
+ /// This function returns the number of items stored in the heap.
int size() const { return 0; }
- /// \brief Checks if the heap is empty.
+ /// \brief Check if the heap is empty.
///
- /// Returns \c true if the heap is empty.
+ /// This function returns \c true if the heap is empty.
bool empty() const { return false; }
- /// \brief Makes the heap empty.
+ /// \brief Make the heap empty.
///
- /// Makes the heap empty.
- void clear();
+ /// 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 Inserts an item into the heap with the given priority.
+ /// \brief Insert an item into the heap with the given priority.
///
- /// Inserts the given item into the heap with the given priority.
+ /// This function inserts the given item into the heap with the
+ /// given priority.
/// \param i The item to insert.
/// \param p The priority of the item.
+ /// \pre \e i must not be stored in the heap.
void push(const Item &i, const Prio &p) {}
- /// \brief Returns the item having minimum priority.
+ /// \brief Return the item having minimum priority.
///
- /// Returns the item having minimum priority.
+ /// This function returns the item having minimum priority.
/// \pre The heap must be non-empty.
Item top() const {}
/// \brief The minimum priority.
///
- /// Returns the minimum priority.
+ /// This function returns the minimum priority.
/// \pre The heap must be non-empty.
Prio prio() const {}
- /// \brief Removes the item having minimum priority.
+ /// \brief Remove the item having minimum priority.
///
- /// Removes the item having minimum priority.
+ /// This function removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {}
- /// \brief Removes an item from the heap.
+ /// \brief Remove the given item from the heap.
///
- /// Removes the given item from the heap if it is already stored.
+ /// 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) {}
- /// \brief The priority of an item.
+ /// \brief The priority of the given item.
///
- /// Returns the priority of the given item.
+ /// This function returns the priority of the given item.
/// \param i The item.
- /// \pre \c i must be in the heap.
+ /// \pre \e i must be in the heap.
Prio operator[](const Item &i) const {}
- /// \brief Sets the priority of an item or inserts it, if it is
+ /// \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 with the given priority.
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
///
/// \param i The item.
/// \param p The priority.
void set(const Item &i, const Prio &p) {}
- /// \brief Decreases the priority of an item to the given value.
+ /// \brief Decrease the priority of an item to the given value.
///
- /// Decreases the priority of an item to the given value.
+ /// This function decreases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
- /// \pre \c i must be stored in the heap with priority at least \c p.
+ /// \pre \e i must be stored in the heap with priority at least \e p.
void decrease(const Item &i, const Prio &p) {}
- /// \brief Increases the priority of an item to the given value.
+ /// \brief Increase the priority of an item to the given value.
///
- /// Increases the priority of an item to the given value.
+ /// This function increases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
- /// \pre \c i must be stored in the heap with priority at most \c p.
+ /// \pre \e i must be stored in the heap with priority at most \e p.
void increase(const Item &i, const Prio &p) {}
- /// \brief Returns if an item is in, has already been in, or has
- /// never been in the heap.
+ /// \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,
@@ -176,11 +198,11 @@
/// \param i The item.
State state(const Item &i) const {}
- /// \brief Sets the state of an item in the heap.
+ /// \brief Set 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.
+ /// 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) {}
diff -r e746fb14e680 -r 432c54cec63c lemon/concepts/maps.h
--- a/lemon/concepts/maps.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/concepts/maps.h Thu Nov 05 08:39:49 2009 +0100
@@ -182,7 +182,8 @@
template<typename _ReferenceMap>
struct Constraints {
- void constraints() {
+ typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type
+ constraints() {
checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
ref = m[key];
m[key] = val;
diff -r e746fb14e680 -r 432c54cec63c lemon/cplex.cc
--- a/lemon/cplex.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/cplex.cc Thu Nov 05 08:39:49 2009 +0100
@@ -111,6 +111,39 @@
return i;
}
+ 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<int> indices;
+ std::vector<int> rowlist;
+ std::vector<Value> 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) {
CPXdelcols(cplexEnv(), _prob, i, i);
diff -r e746fb14e680 -r 432c54cec63c lemon/cplex.h
--- a/lemon/cplex.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/cplex.h Thu Nov 05 08:39:49 2009 +0100
@@ -93,6 +93,7 @@
virtual int _addCol();
virtual int _addRow();
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
virtual void _eraseRow(int i);
diff -r e746fb14e680 -r 432c54cec63c lemon/dfs.h
--- a/lemon/dfs.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/dfs.h Thu Nov 05 08:39:49 2009 +0100
@@ -47,7 +47,7 @@
///
///The type of the map that stores the predecessor
///arcs of the %DFS paths.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
///Instantiates a \c PredMap.
@@ -62,7 +62,8 @@
///The type of the map that indicates which nodes are processed.
///The type of the map that indicates which nodes are processed.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+ ///By default it is a NullMap.
typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
///Instantiates a \c ProcessedMap.
@@ -81,7 +82,7 @@
///The type of the map that indicates which nodes are reached.
///The type of the map that indicates which nodes are reached.
- ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap<bool> ReachedMap;
///Instantiates a \c ReachedMap.
@@ -96,7 +97,7 @@
///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 meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<int> DistMap;
///Instantiates a \c DistMap.
@@ -224,7 +225,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c PredMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
typedef Dfs<Digraph, SetPredMapTraits<T> > Create;
@@ -244,7 +245,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c DistMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
typedef Dfs<Digraph, SetDistMapTraits<T> > Create;
@@ -264,7 +265,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c ReachedMap type.
- ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
template <class T>
struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
@@ -284,7 +285,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c ProcessedMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
typedef Dfs< Digraph, SetProcessedMapTraits<T> > Create;
@@ -411,8 +412,8 @@
///\name Execution Control
///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 more control on the execution, first you have to call
- ///\ref init(), then you can add a source node with \ref addSource()
+ ///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()
///and perform the actual computation with \ref start().
///This procedure can be repeated if there are nodes that have not
///been reached.
@@ -669,9 +670,9 @@
///@{
- ///The DFS path to a node.
+ ///The DFS path to the given node.
- ///Returns the DFS path to a node.
+ ///Returns the DFS path to the given node from the root(s).
///
///\warning \c t should be reached from the root(s).
///
@@ -679,9 +680,9 @@
///must be called before using this function.
Path path(Node t) const { return Path(*G, *_pred, t); }
- ///The distance of a node from the root(s).
+ ///The distance of the given node from the root(s).
- ///Returns the distance of a 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.
@@ -690,7 +691,7 @@
///must be called before using this function.
int dist(Node v) const { return (*_dist)[v]; }
- ///Returns the 'previous arc' of the %DFS tree for a node.
+ ///Returns the 'previous arc' of the %DFS tree for the given node.
///This function returns the 'previous arc' of the %DFS tree for the
///node \c v, i.e. it returns the last arc of a %DFS path from a
@@ -698,21 +699,21 @@
///root(s) or if \c v is a root.
///
///The %DFS tree used here is equal to the %DFS tree used in
- ///\ref predNode().
+ ///\ref predNode() and \ref predMap().
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
Arc predArc(Node v) const { return (*_pred)[v];}
- ///Returns the 'previous node' of the %DFS tree.
+ ///Returns the 'previous node' of the %DFS tree for the given node.
///This function returns the 'previous node' of the %DFS
///tree for the node \c v, i.e. it returns the last but one node
- ///from a %DFS path from a root to \c v. It is \c INVALID
+ ///of 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().
+ ///\ref predArc() and \ref predMap().
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
@@ -733,13 +734,13 @@
///predecessor arcs.
///
///Returns a const reference to the node map that stores the predecessor
- ///arcs, which form the DFS tree.
+ ///arcs, which form the DFS tree (forest).
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
const PredMap &predMap() const { return *_pred;}
- ///Checks if a node is reached from the root(s).
+ ///Checks if the given node. node is reached from the root(s).
///Returns \c true if \c v is reached from the root(s).
///
@@ -765,7 +766,7 @@
///
///The type of the map that stores the predecessor
///arcs of the %DFS paths.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
///Instantiates a PredMap.
@@ -780,7 +781,7 @@
///The type of the map that indicates which nodes are processed.
///The type of the map that indicates which nodes are processed.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
///Instantiates a ProcessedMap.
@@ -800,7 +801,7 @@
///The type of the map that indicates which nodes are reached.
///The type of the map that indicates which nodes are reached.
- ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap<bool> ReachedMap;
///Instantiates a ReachedMap.
@@ -815,7 +816,7 @@
///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 meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<int> DistMap;
///Instantiates a DistMap.
@@ -830,18 +831,14 @@
///The type of the DFS paths.
///The type of the DFS paths.
- ///It must meet the \ref concepts::Path "Path" concept.
+ ///It must conform to the \ref concepts::Path "Path" concept.
typedef lemon::Path<Digraph> Path;
};
/// Default traits class used by DfsWizard
- /// 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.
+ /// Default traits class used by DfsWizard.
+ /// \tparam GR The type of the digraph.
template<class GR>
class DfsWizardBase : public DfsWizardDefaultTraits<GR>
{
@@ -869,7 +866,7 @@
public:
/// Constructor.
- /// This constructor does not require parameters, therefore it initiates
+ /// This constructor does not require parameters, it initiates
/// all of the attributes to \c 0.
DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
_dist(0), _path(0), _di(0) {}
@@ -899,7 +896,6 @@
{
typedef TR Base;
- ///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
typedef typename Digraph::Node Node;
@@ -907,16 +903,10 @@
typedef typename Digraph::Arc Arc;
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;
public:
@@ -999,11 +989,12 @@
static PredMap *createPredMap(const Digraph &) { return 0; };
SetPredMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting PredMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the predecessor map.
///
- ///\ref named-func-param "Named parameter"
- ///for setting PredMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that stores the predecessor arcs of the nodes.
template<class T>
DfsWizard<SetPredMapBase<T> > predMap(const T &t)
{
@@ -1017,11 +1008,12 @@
static ReachedMap *createReachedMap(const Digraph &) { return 0; };
SetReachedMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting ReachedMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the reached map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting ReachedMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that indicates which nodes are reached.
template<class T>
DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
{
@@ -1035,11 +1027,13 @@
static DistMap *createDistMap(const Digraph &) { return 0; };
SetDistMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting DistMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the distance map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting DistMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that stores the distances of the nodes calculated
+ ///by the algorithm.
template<class T>
DfsWizard<SetDistMapBase<T> > distMap(const T &t)
{
@@ -1053,11 +1047,12 @@
static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
SetProcessedMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting ProcessedMap object.
+
+ ///\brief \ref named-func-param "Named parameter" for setting
+ ///the processed map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting ProcessedMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that indicates which nodes are processed.
template<class T>
DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
{
@@ -1208,7 +1203,7 @@
/// \brief The type of the map that indicates which nodes are reached.
///
/// The type of the map that indicates which nodes are reached.
- /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
typedef typename Digraph::template NodeMap<bool> ReachedMap;
/// \brief Instantiates a ReachedMap.
@@ -1369,8 +1364,8 @@
/// \name Execution Control
/// 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 more control on the execution, first you have to call
- /// \ref init(), then you can add a source node with \ref addSource()
+ /// 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()
/// and perform the actual computation with \ref start().
/// This procedure can be repeated if there are nodes that have not
/// been reached.
@@ -1620,7 +1615,7 @@
///@{
- /// \brief Checks if a node is reached from the root(s).
+ /// \brief Checks if the given node is reached from the root(s).
///
/// Returns \c true if \c v is reached from the root(s).
///
diff -r e746fb14e680 -r 432c54cec63c lemon/dijkstra.h
--- a/lemon/dijkstra.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/dijkstra.h Thu Nov 05 08:39:49 2009 +0100
@@ -70,9 +70,9 @@
///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.
+ ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
typedef LEN LengthMap;
- ///The type of the length of the arcs.
+ ///The type of the arc lengths.
typedef typename LEN::Value Value;
/// Operation traits for %Dijkstra algorithm.
@@ -116,7 +116,7 @@
///
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
///Instantiates a \c PredMap.
@@ -131,7 +131,7 @@
///The type of the map that indicates which nodes are processed.
///The type of the map that indicates which nodes are processed.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
///Instantiates a \c ProcessedMap.
@@ -151,7 +151,7 @@
///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 meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
///Instantiates a \c DistMap.
@@ -169,6 +169,10 @@
/// \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
///\ref concepts::ReadMap "ReadMap",
///so it is easy to change it to any kind of length.
@@ -201,7 +205,7 @@
///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
- ///The type of the length of the arcs.
+ ///The type of the arc lengths.
typedef typename TR::LengthMap::Value Value;
///The type of the map that stores the arc lengths.
typedef typename TR::LengthMap LengthMap;
@@ -304,7 +308,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c PredMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetPredMap
: public Dijkstra< Digraph, LengthMap, SetPredMapTraits<T> > {
@@ -325,7 +329,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c DistMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetDistMap
: public Dijkstra< Digraph, LengthMap, SetDistMapTraits<T> > {
@@ -346,7 +350,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c ProcessedMap type.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
template <class T>
struct SetProcessedMap
: public Dijkstra< Digraph, LengthMap, SetProcessedMapTraits<T> > {
@@ -443,6 +447,7 @@
///
///\ref named-templ-param "Named parameter" for setting
///\c OperationTraits type.
+ /// For more information see \ref DijkstraDefaultOperationTraits.
template <class T>
struct SetOperationTraits
: public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
@@ -584,8 +589,8 @@
///\name Execution Control
///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 more control on the execution, first you have to call
- ///\ref init(), then you can add several source nodes with
+ ///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 one of the \ref start() functions.
@@ -801,14 +806,14 @@
///\name Query Functions
///The results of the %Dijkstra algorithm can be obtained using these
///functions.\n
- ///Either \ref run(Node) "run()" or \ref start() should be called
+ ///Either \ref run(Node) "run()" or \ref init() should be called
///before using them.
///@{
- ///The shortest path to a node.
+ ///The shortest path to the given node.
- ///Returns the shortest path to a node.
+ ///Returns the shortest path to the given node from the root(s).
///
///\warning \c t should be reached from the root(s).
///
@@ -816,9 +821,9 @@
///must be called before using this function.
Path path(Node t) const { return Path(*G, *_pred, t); }
- ///The distance of a node from the root(s).
+ ///The distance of the given node from the root(s).
- ///Returns the distance of a 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.
@@ -827,29 +832,31 @@
///must be called before using this function.
Value dist(Node v) const { return (*_dist)[v]; }
- ///Returns the 'previous arc' of the shortest path tree for a node.
-
+ ///\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 the 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().
+ ///tree used in \ref predNode() and \ref predMap().
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
Arc predArc(Node v) const { return (*_pred)[v]; }
- ///Returns the 'previous node' of the shortest path tree for a node.
-
+ ///\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 the node \c v, i.e. it returns the last but one node
- ///from a shortest path from a root to \c v. It is \c INVALID
+ ///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().
+ ///tree used in \ref predArc() and \ref predMap().
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
@@ -870,13 +877,13 @@
///predecessor arcs.
///
///Returns a const reference to the node map that stores the predecessor
- ///arcs, which form the shortest path tree.
+ ///arcs, which form the shortest path tree (forest).
///
///\pre Either \ref run(Node) "run()" or \ref init()
///must be called before using this function.
const PredMap &predMap() const { return *_pred;}
- ///Checks if a node is reached from the root(s).
+ ///Checks if the given node is reached from the root(s).
///Returns \c true if \c v is reached from the root(s).
///
@@ -895,9 +902,9 @@
bool processed(Node v) const { return (*_heap_cross_ref)[v] ==
Heap::POST_HEAP; }
- ///The current distance of a node from the root(s).
+ ///The current distance of the given node from the root(s).
- ///Returns the current distance of a node from the root(s).
+ ///Returns the current distance of the given node from the root(s).
///It may be decreased in the following processes.
///
///\pre Either \ref run(Node) "run()" or \ref init()
@@ -924,9 +931,9 @@
///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.
+ ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
typedef LEN LengthMap;
- ///The type of the length of the arcs.
+ ///The type of the arc lengths.
typedef typename LEN::Value Value;
/// Operation traits for Dijkstra algorithm.
@@ -973,7 +980,7 @@
///
///The type of the map that stores the predecessor
///arcs of the shortest paths.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
///Instantiates a PredMap.
@@ -988,7 +995,7 @@
///The type of the map that indicates which nodes are processed.
///The type of the map that indicates which nodes are processed.
- ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
///By default it is a NullMap.
typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
///Instantiates a ProcessedMap.
@@ -1008,7 +1015,7 @@
///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 meet the \ref concepts::WriteMap "WriteMap" concept.
+ ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
///Instantiates a DistMap.
@@ -1023,18 +1030,15 @@
///The type of the shortest paths.
///The type of the shortest paths.
- ///It must meet the \ref concepts::Path "Path" concept.
+ ///It must conform to the \ref concepts::Path "Path" concept.
typedef lemon::Path<Digraph> Path;
};
/// Default traits class used by DijkstraWizard
- /// 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.
+ /// Default traits class used by DijkstraWizard.
+ /// \tparam GR The type of the digraph.
+ /// \tparam LEN The type of the length map.
template<typename GR, typename LEN>
class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
{
@@ -1093,7 +1097,6 @@
{
typedef TR Base;
- ///The type of the digraph the algorithm runs on.
typedef typename TR::Digraph Digraph;
typedef typename Digraph::Node Node;
@@ -1101,20 +1104,12 @@
typedef typename Digraph::Arc Arc;
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;
public:
@@ -1186,11 +1181,12 @@
static PredMap *createPredMap(const Digraph &) { return 0; };
SetPredMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting PredMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the predecessor map.
///
- ///\ref named-func-param "Named parameter"
- ///for setting PredMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that stores the predecessor arcs of the nodes.
template<class T>
DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
{
@@ -1204,11 +1200,13 @@
static DistMap *createDistMap(const Digraph &) { return 0; };
SetDistMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting DistMap object.
+
+ ///\brief \ref named-templ-param "Named parameter" for setting
+ ///the distance map.
///
- ///\ref named-func-param "Named parameter"
- ///for setting DistMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that stores the distances of the nodes calculated
+ ///by the algorithm.
template<class T>
DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
{
@@ -1222,11 +1220,12 @@
static ProcessedMap *createProcessedMap(const Digraph &) { return 0; };
SetProcessedMapBase(const TR &b) : TR(b) {}
};
- ///\brief \ref named-func-param "Named parameter"
- ///for setting ProcessedMap object.
+
+ ///\brief \ref named-func-param "Named parameter" for setting
+ ///the processed map.
///
- /// \ref named-func-param "Named parameter"
- ///for setting ProcessedMap object.
+ ///\ref named-templ-param "Named parameter" function for setting
+ ///the map that indicates which nodes are processed.
template<class T>
DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
{
@@ -1239,6 +1238,7 @@
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.
///
diff -r e746fb14e680 -r 432c54cec63c lemon/dim2.h
--- a/lemon/dim2.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/dim2.h Thu Nov 05 08:39:49 2009 +0100
@@ -21,16 +21,9 @@
#include <iostream>
-///\ingroup misc
+///\ingroup geomdat
///\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 {
@@ -40,7 +33,7 @@
///tools for handling two dimensional coordinates
namespace dim2 {
- /// \addtogroup misc
+ /// \addtogroup geomdat
/// @{
/// Two dimensional vector (plain vector)
diff -r e746fb14e680 -r 432c54cec63c lemon/fib_heap.h
--- a/lemon/fib_heap.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/fib_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -20,53 +20,49 @@
#define LEMON_FIB_HEAP_H
///\file
-///\ingroup auxdat
-///\brief Fibonacci Heap implementation.
+///\ingroup heaps
+///\brief Fibonacci heap implementation.
#include <vector>
+#include <utility>
#include <functional>
#include <lemon/math.h>
namespace lemon {
- /// \ingroup auxdat
+ /// \ingroup heaps
///
- ///\brief Fibonacci Heap.
+ /// \brief Fibonacci heap data structure.
///
- ///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.
+ /// This class implements the \e Fibonacci \e heap data structure.
+ /// It fully conforms to the \ref concepts::Heap "heap concept".
///
- ///The methods \ref increase and \ref erase are not efficient in a Fibonacci
- ///heap. In case of many calls to these operations, it is better to use a
- ///\ref BinHeap "binary heap".
+ /// 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".
///
- ///\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<PRIO>.
- ///
- ///\sa BinHeap
- ///\sa Dijkstra
+ /// \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<PR>.
#ifdef DOXYGEN
- template <typename PRIO, typename IM, typename CMP>
+ template <typename PR, typename IM, typename CMP>
#else
- template <typename PRIO, typename IM, typename CMP = std::less<PRIO> >
+ template <typename PR, typename IM, typename CMP = std::less<PR> >
#endif
class FibHeap {
public:
- ///\e
+
+ /// Type of the item-int map.
typedef IM ItemIntMap;
- ///\e
- typedef PRIO Prio;
- ///\e
+ /// Type of the priorities.
+ typedef PR Prio;
+ /// Type of the items stored in the heap.
typedef typename ItemIntMap::Key Item;
- ///\e
+ /// Type of the item-priority pairs.
typedef std::pair<Item,Prio> Pair;
- ///\e
+ /// Functor type for comparing the priorities.
typedef CMP Compare;
private:
@@ -80,10 +76,10 @@
public:
- /// \brief Type to represent the items states.
+ /// \brief Type to represent the states of the items.
///
- /// 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
+ /// 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
@@ -94,60 +90,54 @@
POST_HEAP = -2 ///< = -2.
};
- /// \brief The constructor
+ /// \brief Constructor.
///
- /// \c map should be given to the constructor, since it is
- /// used internally to handle the cross references.
+ /// 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 (<tt>-1</tt>) for each item.
explicit FibHeap(ItemIntMap &map)
: _minimum(0), _iim(map), _num() {}
- /// \brief The constructor
+ /// \brief 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.
+ /// 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 (<tt>-1</tt>) for each item.
+ /// \param comp The function object used for comparing the priorities.
FibHeap(ItemIntMap &map, const Compare &comp)
: _minimum(0), _iim(map), _comp(comp), _num() {}
/// \brief The number of items stored in the heap.
///
- /// Returns the number of items stored in the heap.
+ /// This function returns the number of items stored in the heap.
int size() const { return _num; }
- /// \brief Checks if the heap stores no items.
+ /// \brief Check if the heap is empty.
///
- /// Returns \c true if and only if the heap stores no items.
+ /// This function returns \c true if the heap is empty.
bool empty() const { return _num==0; }
- /// \brief Make empty this heap.
+ /// \brief Make the heap empty.
///
- /// 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.
+ /// This functon makes the heap empty.
+ /// It does not change the cross reference map. If you want to reuse
+ /// a heap that is not surely empty, you should first clear it and
+ /// then you should set the cross reference map to \c PRE_HEAP
+ /// for each item.
void clear() {
_data.clear(); _minimum = 0; _num = 0;
}
- /// \brief \c item gets to the heap with priority \c value independently
- /// if \c item was already there.
+ /// \brief Insert an item into the heap with the given priority.
///
- /// 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) {
+ /// This function inserts the given item into the heap with the
+ /// given priority.
+ /// \param item The item to insert.
+ /// \param prio The priority of the item.
+ /// \pre \e item must not be stored in the heap.
+ void push (const Item& item, const Prio& prio) {
int i=_iim[item];
if ( i < 0 ) {
int s=_data.size();
@@ -168,47 +158,37 @@
_data[i].right_neighbor=_data[_minimum].right_neighbor;
_data[_minimum].right_neighbor=i;
_data[i].left_neighbor=_minimum;
- if ( _comp( value, _data[_minimum].prio) ) _minimum=i;
+ if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
} else {
_data[i].right_neighbor=_data[i].left_neighbor=i;
_minimum=i;
}
- _data[i].prio=value;
+ _data[i].prio=prio;
++_num;
}
- /// \brief Returns the item with minimum priority relative to \c Compare.
+ /// \brief Return the item having minimum priority.
///
- /// This method returns the item with minimum priority relative to \c
- /// Compare.
- /// \pre The heap must be nonempty.
+ /// This function returns the item having minimum priority.
+ /// \pre The heap must be non-empty.
Item top() const { return _data[_minimum].name; }
- /// \brief Returns the minimum priority relative to \c Compare.
+ /// \brief The minimum priority.
///
- /// It returns the minimum priority relative to \c Compare.
- /// \pre The heap must be nonempty.
- const Prio& prio() const { return _data[_minimum].prio; }
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
+ Prio prio() const { return _data[_minimum].prio; }
- /// \brief Returns the priority of \c item.
+ /// \brief Remove the item having minimum priority.
///
- /// 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.
+ /// This function removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {
/*The first case is that there are only one root.*/
if ( _data[_minimum].left_neighbor==_minimum ) {
_data[_minimum].in=false;
if ( _data[_minimum].degree!=0 ) {
- makeroot(_data[_minimum].child);
+ makeRoot(_data[_minimum].child);
_minimum=_data[_minimum].child;
balance();
}
@@ -221,7 +201,7 @@
int child=_data[_minimum].child;
int last_child=_data[child].left_neighbor;
- makeroot(child);
+ makeRoot(child);
_data[left].right_neighbor=child;
_data[child].left_neighbor=left;
@@ -234,10 +214,12 @@
--_num;
}
- /// \brief Deletes \c item from the heap.
+ /// \brief Remove the given 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.
+ /// 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];
@@ -252,43 +234,68 @@
}
}
- /// \brief Decreases the priority of \c item to \c value.
+ /// \brief The priority of the given item.
///
- /// 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) {
+ /// This function returns the priority of the given item.
+ /// \param item The item.
+ /// \pre \e item must be in the heap.
+ Prio operator[](const Item& item) const {
+ return _data[_iim[item]].prio;
+ }
+
+ /// \brief Set the priority of an item or insert it, if it is
+ /// not stored in the heap.
+ ///
+ /// This method sets the priority of the given item if it is
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
+ /// \param item The item.
+ /// \param prio The priority.
+ void set (const Item& item, const Prio& prio) {
int i=_iim[item];
- _data[i].prio=value;
+ if ( i >= 0 && _data[i].in ) {
+ if ( _comp(prio, _data[i].prio) ) decrease(item, prio);
+ if ( _comp(_data[i].prio, prio) ) increase(item, prio);
+ } else push(item, prio);
+ }
+
+ /// \brief Decrease the priority of an item to the given value.
+ ///
+ /// This function decreases the priority of an item to the given value.
+ /// \param item The item.
+ /// \param prio The priority.
+ /// \pre \e item must be stored in the heap with priority at least \e prio.
+ void decrease (const Item& item, const Prio& prio) {
+ int i=_iim[item];
+ _data[i].prio=prio;
int p=_data[i].parent;
- if ( p!=-1 && _comp(value, _data[p].prio) ) {
+ if ( p!=-1 && _comp(prio, _data[p].prio) ) {
cut(i,p);
cascade(p);
}
- if ( _comp(value, _data[_minimum].prio) ) _minimum=i;
+ if ( _comp(prio, _data[_minimum].prio) ) _minimum=i;
}
- /// \brief Increases the priority of \c item to \c value.
+ /// \brief Increase the priority of an item to the given 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) {
+ /// This function increases the priority of an item to the given value.
+ /// \param item The item.
+ /// \param prio The priority.
+ /// \pre \e item must be stored in the heap with priority at most \e prio.
+ void increase (const Item& item, const Prio& prio) {
erase(item);
- push(item, value);
+ push(item, prio);
}
-
- /// \brief Returns if \c item is in, has already been in, or has never
- /// been in the heap.
+ /// \brief Return the state of an item.
///
- /// 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.
+ /// 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 ) {
@@ -298,11 +305,11 @@
return State(i);
}
- /// \brief Sets the state of the \c item in the heap.
+ /// \brief Set the state of an 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.
+ /// 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) {
@@ -365,7 +372,7 @@
} while ( s != m );
}
- void makeroot(int c) {
+ void makeRoot(int c) {
int s=c;
do {
_data[s].parent=-1;
diff -r e746fb14e680 -r 432c54cec63c lemon/fourary_heap.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/fourary_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,342 @@
+/* -*- 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 <vector>
+#include <utility>
+#include <functional>
+
+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 <tt>K=4</tt>. 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<PR>.
+ ///
+ ///\sa BinHeap
+ ///\sa KaryHeap
+#ifdef DOXYGEN
+ template <typename PR, typename IM, typename CMP>
+#else
+ template <typename PR, typename IM, typename CMP = std::less<PR> >
+#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<Item,Prio> 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 (<tt>-1</tt>) 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<Pair> _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 (<tt>-1</tt>) 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 (<tt>-1</tt>) 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+3<length ) {
+ int min=child;
+ if( less(_data[++child], _data[min]) ) min=child;
+ if( less(_data[++child], _data[min]) ) min=child;
+ if( less(_data[++child], _data[min]) ) min=child;
+ if( !less(_data[min], p) )
+ goto ok;
+ move(_data[min], hole);
+ hole = min;
+ child = firstChild(hole);
+ }
+ if ( child<length ) {
+ int min = child;
+ if( ++child<length && less(_data[child], _data[min]) ) min=child;
+ if( ++child<length && less(_data[child], _data[min]) ) min=child;
+ if( less(_data[min], p) ) {
+ move(_data[min], hole);
+ hole = min;
+ }
+ }
+ }
+ ok:
+ move(p, hole);
+ }
+
+ void move(const Pair &p, int i) {
+ _data[i] = p;
+ _iim.set(p.first, i);
+ }
+
+ public:
+ /// \brief Insert a pair of item and priority into the heap.
+ ///
+ /// This function inserts \c p.first to the heap with priority
+ /// \c p.second.
+ /// \param p The pair to insert.
+ /// \pre \c p.first must not be stored in the heap.
+ void push(const Pair &p) {
+ 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.
+ /// \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.
+ Item top() const { return _data[0].first; }
+
+ /// \brief The minimum priority.
+ ///
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
+ Prio prio() const { return _data[0].second; }
+
+ /// \brief Remove the item having minimum priority.
+ ///
+ /// This function removes the item having minimum priority.
+ /// \pre The heap must be non-empty.
+ void pop() {
+ int n = _data.size()-1;
+ _iim.set(_data[0].first, POST_HEAP);
+ if (n>0) 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<n ) {
+ if( less(_data[parent(h)], _data[n]) )
+ bubbleDown(h, _data[n], n);
+ else
+ bubbleUp(h, _data[n]);
+ }
+ _data.pop_back();
+ }
+
+ /// \brief The priority of the given item.
+ ///
+ /// This function returns the priority of the given item.
+ /// \param i The item.
+ /// \pre \e i must be in the heap.
+ Prio operator[](const Item &i) const {
+ int idx = _iim[i];
+ return _data[idx].second;
+ }
+
+ /// \brief Set the priority of an item or insert it, if it is
+ /// not stored in the heap.
+ ///
+ /// This method sets the priority of the given item if it is
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
+ /// \param i The item.
+ /// \param p The priority.
+ void set(const Item &i, const Prio &p) {
+ int idx = _iim[i];
+ if( idx < 0 )
+ push(i,p);
+ else if( _comp(p, _data[idx].second) )
+ bubbleUp(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.
+ /// \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];
+ 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.
+ /// \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];
+ 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.
+ /// \param i The item.
+ State state(const Item &i) const {
+ int s = _iim[i];
+ if (s>=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
diff -r e746fb14e680 -r 432c54cec63c lemon/full_graph.h
--- a/lemon/full_graph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/full_graph.h Thu Nov 05 08:39:49 2009 +0100
@@ -24,7 +24,7 @@
///\ingroup graphs
///\file
-///\brief FullGraph and FullDigraph classes.
+///\brief FullDigraph and FullGraph classes.
namespace lemon {
@@ -148,24 +148,26 @@
/// \ingroup graphs
///
- /// \brief A full digraph class.
+ /// \brief A directed full graph 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.
+ /// 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 class fully conforms to the \ref concepts::Digraph
- /// "Digraph concept".
+ /// 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.
///
- /// The \c FullDigraph and \c FullGraph classes are very similar,
+ /// \note FullDigraph and FullGraph classes are very similar,
/// but there are two differences. While this class conforms only
- /// 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.
+ /// 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.
///
/// \sa FullGraph
class FullDigraph : public ExtendedFullDigraphBase {
@@ -173,7 +175,9 @@
public:
- /// \brief Constructor
+ /// \brief Default constructor.
+ ///
+ /// Default constructor. The number of nodes and arcs will be zero.
FullDigraph() { construct(0); }
/// \brief Constructor
@@ -184,8 +188,8 @@
/// \brief Resizes the digraph
///
- /// Resizes the digraph. The function will fully destroy and
- /// rebuild the digraph. This cause that the maps of the digraph will
+ /// This function resizes the digraph. It fully destroys and
+ /// rebuilds the structure, therefore the maps of the digraph will be
/// reallocated automatically and the previous values will be lost.
void resize(int n) {
Parent::notifier(Arc()).clear();
@@ -197,24 +201,24 @@
/// \brief Returns the node with the given index.
///
- /// Returns the node with the given index. Since it is a static
- /// digraph its nodes can be indexed with integers from the range
- /// <tt>[0..nodeNum()-1]</tt>.
+ /// Returns the node with the given index. Since this structure is
+ /// completely static, the nodes can be indexed with integers from
+ /// the range <tt>[0..nodeNum()-1]</tt>.
/// \sa index()
Node operator()(int ix) const { return Parent::operator()(ix); }
/// \brief Returns the index of the given node.
///
- /// Returns the index of the given node. Since it is a static
- /// digraph its nodes can be indexed with integers from the range
- /// <tt>[0..nodeNum()-1]</tt>.
- /// \sa operator()
- int index(const Node& node) const { return Parent::index(node); }
+ /// Returns the index of the given node. Since this structure is
+ /// completely static, the nodes can be indexed with integers from
+ /// the range <tt>[0..nodeNum()-1]</tt>.
+ /// \sa operator()()
+ int index(Node node) const { return Parent::index(node); }
/// \brief Returns the arc connecting the given nodes.
///
/// Returns the arc connecting the given nodes.
- Arc arc(const Node& u, const Node& v) const {
+ Arc arc(Node u, Node v) const {
return Parent::arc(u, v);
}
@@ -520,21 +524,23 @@
///
/// \brief An undirected full graph class.
///
- /// 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.
+ /// 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 <tt>n(n-1)/2</tt>.
+ /// 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 class fully conforms to the \ref concepts::Graph "Graph concept".
+ /// 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.
///
- /// The \c FullGraph and \c FullDigraph classes are very similar,
- /// but there are two differences. While the \c FullDigraph class
+ /// \note FullDigraph and FullGraph classes are very similar,
+ /// but there are two differences. While FullDigraph
/// conforms only to the \ref concepts::Digraph "Digraph" concept,
/// this 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.
+ /// moreover this class does not contain a loop for each
+ /// node as FullDigraph does.
///
/// \sa FullDigraph
class FullGraph : public ExtendedFullGraphBase {
@@ -542,7 +548,9 @@
public:
- /// \brief Constructor
+ /// \brief Default constructor.
+ ///
+ /// Default constructor. The number of nodes and edges will be zero.
FullGraph() { construct(0); }
/// \brief Constructor
@@ -553,8 +561,8 @@
/// \brief Resizes the graph
///
- /// Resizes the graph. The function will fully destroy and
- /// rebuild the graph. This cause that the maps of the graph will
+ /// This function resizes the graph. It fully destroys and
+ /// rebuilds the structure, therefore the maps of the graph will be
/// reallocated automatically and the previous values will be lost.
void resize(int n) {
Parent::notifier(Arc()).clear();
@@ -568,31 +576,31 @@
/// \brief Returns the node with the given index.
///
- /// Returns the node with the given index. Since it is a static
- /// graph its nodes can be indexed with integers from the range
- /// <tt>[0..nodeNum()-1]</tt>.
+ /// Returns the node with the given index. Since this structure is
+ /// completely static, the nodes can be indexed with integers from
+ /// the range <tt>[0..nodeNum()-1]</tt>.
/// \sa index()
Node operator()(int ix) const { return Parent::operator()(ix); }
/// \brief Returns the index of the given node.
///
- /// Returns the index of the given node. Since it is a static
- /// graph its nodes can be indexed with integers from the range
- /// <tt>[0..nodeNum()-1]</tt>.
- /// \sa operator()
- int index(const Node& node) const { return Parent::index(node); }
+ /// Returns the index of the given node. Since this structure is
+ /// completely static, the nodes can be indexed with integers from
+ /// the range <tt>[0..nodeNum()-1]</tt>.
+ /// \sa operator()()
+ int index(Node node) const { return Parent::index(node); }
/// \brief Returns the arc connecting the given nodes.
///
/// Returns the arc connecting the given nodes.
- Arc arc(const Node& s, const Node& t) const {
+ Arc arc(Node s, Node t) const {
return Parent::arc(s, t);
}
- /// \brief Returns the edge connects the given nodes.
+ /// \brief Returns the edge connecting the given nodes.
///
- /// Returns the edge connects the given nodes.
- Edge edge(const Node& u, const Node& v) const {
+ /// Returns the edge connecting the given nodes.
+ Edge edge(Node u, Node v) const {
return Parent::edge(u, v);
}
diff -r e746fb14e680 -r 432c54cec63c lemon/glpk.cc
--- a/lemon/glpk.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/glpk.cc Thu Nov 05 08:39:49 2009 +0100
@@ -59,6 +59,42 @@
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<int> indexes;
+ std::vector<Value> 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;
+ }
+
void GlpkBase::_eraseCol(int i) {
int ca[2];
ca[1] = i;
diff -r e746fb14e680 -r 432c54cec63c lemon/glpk.h
--- a/lemon/glpk.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/glpk.h Thu Nov 05 08:39:49 2009 +0100
@@ -54,6 +54,7 @@
virtual int _addCol();
virtual int _addRow();
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
virtual void _eraseRow(int i);
diff -r e746fb14e680 -r 432c54cec63c lemon/gomory_hu.h
--- a/lemon/gomory_hu.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/gomory_hu.h Thu Nov 05 08:39:49 2009 +0100
@@ -359,10 +359,10 @@
/// This example counts the nodes in the minimum cut separating \c s from
/// \c t.
/// \code
- /// GomoruHu<Graph> gom(g, capacities);
+ /// GomoryHu<Graph> gom(g, capacities);
/// gom.run();
/// int cnt=0;
- /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
+ /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
/// \endcode
class MinCutNodeIt
{
@@ -456,10 +456,10 @@
/// This example computes the value of the minimum cut separating \c s from
/// \c t.
/// \code
- /// GomoruHu<Graph> gom(g, capacities);
+ /// GomoryHu<Graph> gom(g, capacities);
/// gom.run();
/// int value=0;
- /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
+ /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
/// value+=capacities[e];
/// \endcode
/// The result will be the same as the value returned by
diff -r e746fb14e680 -r 432c54cec63c lemon/grid_graph.h
--- a/lemon/grid_graph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/grid_graph.h Thu Nov 05 08:39:49 2009 +0100
@@ -470,18 +470,22 @@
///
/// \brief Grid graph class
///
- /// This class implements a special graph type. The nodes of the
- /// graph can be indexed by two integer \c (i,j) value where \c i is
- /// in the \c [0..width()-1] range and j is in the \c
- /// [0..height()-1] range. Two nodes are connected in the graph if
- /// the indexes differ exactly on one position and exactly one is
- /// the difference. The nodes of the graph can be indexed by position
- /// with the \c operator()() function. The positions of the nodes can be
- /// get with \c pos(), \c col() and \c row() members. The outgoing
+ /// GridGraph implements a special graph type. The nodes of the
+ /// graph can be indexed by two integer values \c (i,j) where \c i is
+ /// in the range <tt>[0..width()-1]</tt> and j is in the range
+ /// <tt>[0..height()-1]</tt>. Two nodes are connected in the graph if
+ /// the indices differ exactly on one position and the difference is
+ /// also exactly one. The nodes of the graph can be obtained by position
+ /// using the \c operator()() function and the indices of the nodes can
+ /// be obtained using \c pos(), \c col() and \c row() members. The outgoing
/// arcs can be retrieved with the \c right(), \c up(), \c left()
/// and \c down() functions, where the bottom-left corner is the
/// origin.
///
+ /// 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().
+ ///
/// \image html grid_graph.png
/// \image latex grid_graph.eps "Grid graph" width=\textwidth
///
@@ -496,16 +500,19 @@
/// }
///\endcode
///
- /// This graph type fully conforms to the \ref concepts::Graph
- /// "Graph concept".
+ /// 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.
class GridGraph : public ExtendedGridGraphBase {
typedef ExtendedGridGraphBase Parent;
public:
- /// \brief Map to get the indices of the nodes as dim2::Point<int>.
+ /// \brief Map to get the indices of the nodes as \ref dim2::Point
+ /// "dim2::Point<int>".
///
- /// Map to get the indices of the nodes as dim2::Point<int>.
+ /// Map to get the indices of the nodes as \ref dim2::Point
+ /// "dim2::Point<int>".
class IndexMap {
public:
/// \brief The key type of the map
@@ -514,13 +521,9 @@
typedef dim2::Point<int> Value;
/// \brief Constructor
- ///
- /// Constructor
IndexMap(const GridGraph& graph) : _graph(graph) {}
/// \brief The subscript operator
- ///
- /// The subscript operator.
Value operator[](Key key) const {
return _graph.pos(key);
}
@@ -540,13 +543,9 @@
typedef int Value;
/// \brief Constructor
- ///
- /// Constructor
ColMap(const GridGraph& graph) : _graph(graph) {}
/// \brief The subscript operator
- ///
- /// The subscript operator.
Value operator[](Key key) const {
return _graph.col(key);
}
@@ -566,13 +565,9 @@
typedef int Value;
/// \brief Constructor
- ///
- /// Constructor
RowMap(const GridGraph& graph) : _graph(graph) {}
/// \brief The subscript operator
- ///
- /// The subscript operator.
Value operator[](Key key) const {
return _graph.row(key);
}
@@ -583,15 +578,14 @@
/// \brief Constructor
///
- /// Construct a grid graph with given size.
+ /// Construct a grid graph with the given size.
GridGraph(int width, int height) { construct(width, height); }
- /// \brief Resize the graph
+ /// \brief Resizes the graph
///
- /// Resize 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.
+ /// This function resizes the graph. It fully destroys and
+ /// rebuilds the structure, therefore the maps of the graph will be
+ /// reallocated automatically and the previous values will be lost.
void resize(int width, int height) {
Parent::notifier(Arc()).clear();
Parent::notifier(Edge()).clear();
@@ -609,42 +603,42 @@
return Parent::operator()(i, j);
}
- /// \brief Gives back the column index of the node.
+ /// \brief The column index of the node.
///
/// Gives back the column index of the node.
int col(Node n) const {
return Parent::col(n);
}
- /// \brief Gives back the row index of the node.
+ /// \brief The row index of the node.
///
/// Gives back the row index of the node.
int row(Node n) const {
return Parent::row(n);
}
- /// \brief Gives back the position of the node.
+ /// \brief The position of the node.
///
/// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair.
dim2::Point<int> pos(Node n) const {
return Parent::pos(n);
}
- /// \brief Gives back the number of the columns.
+ /// \brief The number of the columns.
///
/// Gives back the number of the columns.
int width() const {
return Parent::width();
}
- /// \brief Gives back the number of the rows.
+ /// \brief The number of the rows.
///
/// Gives back the number of the rows.
int height() const {
return Parent::height();
}
- /// \brief Gives back the arc goes right from the node.
+ /// \brief The arc goes right from the node.
///
/// Gives back the arc goes right from the node. If there is not
/// outgoing arc then it gives back INVALID.
@@ -652,7 +646,7 @@
return Parent::right(n);
}
- /// \brief Gives back the arc goes left from the node.
+ /// \brief The arc goes left from the node.
///
/// Gives back the arc goes left from the node. If there is not
/// outgoing arc then it gives back INVALID.
@@ -660,7 +654,7 @@
return Parent::left(n);
}
- /// \brief Gives back the arc goes up from the node.
+ /// \brief The arc goes up from the node.
///
/// Gives back the arc goes up from the node. If there is not
/// outgoing arc then it gives back INVALID.
@@ -668,7 +662,7 @@
return Parent::up(n);
}
- /// \brief Gives back the arc goes down from the node.
+ /// \brief The arc goes down from the node.
///
/// Gives back the arc goes down from the node. If there is not
/// outgoing arc then it gives back INVALID.
diff -r e746fb14e680 -r 432c54cec63c lemon/hypercube_graph.h
--- a/lemon/hypercube_graph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/hypercube_graph.h Thu Nov 05 08:39:49 2009 +0100
@@ -282,17 +282,21 @@
///
/// \brief Hypercube graph class
///
- /// This class implements a special graph type. The nodes of the graph
- /// are indiced with integers with at most \c dim binary digits.
+ /// HypercubeGraph implements a special graph type. The nodes of the
+ /// graph are indexed with integers having at most \c dim binary digits.
/// Two nodes are connected in the graph if and only if their indices
/// differ only on one position in the binary form.
+ /// 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 The type of the indices is chosen to \c int for efficiency
/// reasons. Thus the maximum dimension of this implementation is 26
/// (assuming that the size of \c int is 32 bit).
- ///
- /// This graph type fully conforms to the \ref concepts::Graph
- /// "Graph concept".
class HypercubeGraph : public ExtendedHypercubeGraphBase {
typedef ExtendedHypercubeGraphBase Parent;
@@ -303,6 +307,21 @@
/// Constructs a hypercube graph with \c dim dimensions.
HypercubeGraph(int dim) { construct(dim); }
+ /// \brief Resizes the graph
+ ///
+ /// This function resizes the graph. It fully destroys and
+ /// rebuilds the structure, therefore the maps of the graph will be
+ /// reallocated automatically and the previous values will be lost.
+ void resize(int dim) {
+ Parent::notifier(Arc()).clear();
+ Parent::notifier(Edge()).clear();
+ Parent::notifier(Node()).clear();
+ construct(dim);
+ Parent::notifier(Node()).build();
+ Parent::notifier(Edge()).build();
+ Parent::notifier(Arc()).build();
+ }
+
/// \brief The number of dimensions.
///
/// Gives back the number of dimensions.
@@ -320,7 +339,7 @@
/// \brief The dimension id of an edge.
///
/// Gives back the dimension id of the given edge.
- /// It is in the [0..dim-1] range.
+ /// It is in the range <tt>[0..dim-1]</tt>.
int dimension(Edge edge) const {
return Parent::dimension(edge);
}
@@ -328,7 +347,7 @@
/// \brief The dimension id of an arc.
///
/// Gives back the dimension id of the given arc.
- /// It is in the [0..dim-1] range.
+ /// It is in the range <tt>[0..dim-1]</tt>.
int dimension(Arc arc) const {
return Parent::dimension(arc);
}
diff -r e746fb14e680 -r 432c54cec63c lemon/kary_heap.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/kary_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,352 @@
+/* -*- 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_KARY_HEAP_H
+#define LEMON_KARY_HEAP_H
+
+///\ingroup heaps
+///\file
+///\brief Fourary heap implementation.
+
+#include <vector>
+#include <utility>
+#include <functional>
+
+namespace lemon {
+
+ /// \ingroup heaps
+ ///
+ ///\brief K-ary heap data structure.
+ ///
+ /// This class implements the \e K-ary \e heap data structure.
+ /// It fully conforms to the \ref concepts::Heap "heap concept".
+ ///
+ /// The \ref KaryHeap "K-ary heap" is a generalization of the
+ /// \ref BinHeap "binary heap" structure, its nodes have at most
+ /// \c K children, instead of two.
+ /// \ref BinHeap and \ref FouraryHeap are specialized implementations
+ /// of this structure for <tt>K=2</tt> and <tt>K=4</tt>, respectively.
+ ///
+ /// \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 K The degree of the heap, each node have at most \e K
+ /// children. The default is 16. Powers of two are suggested to use
+ /// so that the multiplications and divisions needed to traverse the
+ /// nodes of the heap could be performed faster.
+ /// \tparam CMP A functor class for comparing the priorities.
+ /// The default is \c std::less<PR>.
+ ///
+ ///\sa BinHeap
+ ///\sa FouraryHeap
+#ifdef DOXYGEN
+ template <typename PR, typename IM, int K, typename CMP>
+#else
+ template <typename PR, typename IM, int K = 16,
+ typename CMP = std::less<PR> >
+#endif
+ class KaryHeap {
+ 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<Item,Prio> 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 (<tt>-1</tt>) 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<Pair> _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 (<tt>-1</tt>) for each item.
+ explicit KaryHeap(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 (<tt>-1</tt>) for each item.
+ /// \param comp The function object used for comparing the priorities.
+ KaryHeap(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:
+ int parent(int i) { return (i-1)/K; }
+ int firstChild(int i) { return K*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+K<=length ) {
+ int min=child;
+ for (int i=1; i<K; ++i) {
+ if( less(_data[child+i], _data[min]) )
+ min=child+i;
+ }
+ if( !less(_data[min], p) )
+ goto ok;
+ move(_data[min], hole);
+ hole = min;
+ child = firstChild(hole);
+ }
+ if ( child<length ) {
+ int min = child;
+ while (++child < length) {
+ if( less(_data[child], _data[min]) )
+ min=child;
+ }
+ if( less(_data[min], p) ) {
+ move(_data[min], hole);
+ hole = min;
+ }
+ }
+ }
+ ok:
+ move(p, hole);
+ }
+
+ void move(const Pair &p, int i) {
+ _data[i] = p;
+ _iim.set(p.first, i);
+ }
+
+ public:
+ /// \brief Insert a pair of item and priority into the heap.
+ ///
+ /// This function inserts \c p.first to the heap with priority
+ /// \c p.second.
+ /// \param p The pair to insert.
+ /// \pre \c p.first must not be stored in the heap.
+ void push(const Pair &p) {
+ 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.
+ /// \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.
+ Item top() const { return _data[0].first; }
+
+ /// \brief The minimum priority.
+ ///
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
+ Prio prio() const { return _data[0].second; }
+
+ /// \brief Remove the item having minimum priority.
+ ///
+ /// This function removes the item having minimum priority.
+ /// \pre The heap must be non-empty.
+ void pop() {
+ int n = _data.size()-1;
+ _iim.set(_data[0].first, POST_HEAP);
+ if (n>0) 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<n ) {
+ if( less(_data[parent(h)], _data[n]) )
+ bubbleDown(h, _data[n], n);
+ else
+ bubbleUp(h, _data[n]);
+ }
+ _data.pop_back();
+ }
+
+ /// \brief The priority of the given item.
+ ///
+ /// This function returns the priority of the given item.
+ /// \param i The item.
+ /// \pre \e i must be in the heap.
+ Prio operator[](const Item &i) const {
+ int idx = _iim[i];
+ return _data[idx].second;
+ }
+
+ /// \brief Set the priority of an item or insert it, if it is
+ /// not stored in the heap.
+ ///
+ /// This method sets the priority of the given item if it is
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
+ /// \param i The item.
+ /// \param p The priority.
+ void set(const Item &i, const Prio &p) {
+ int idx = _iim[i];
+ if( idx<0 )
+ push(i,p);
+ else if( _comp(p, _data[idx].second) )
+ bubbleUp(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.
+ /// \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];
+ 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.
+ /// \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];
+ 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.
+ /// \param i The item.
+ State state(const Item &i) const {
+ int s = _iim[i];
+ if (s>=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 KaryHeap
+
+} // namespace lemon
+
+#endif // LEMON_KARY_HEAP_H
diff -r e746fb14e680 -r 432c54cec63c lemon/list_graph.h
--- a/lemon/list_graph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/list_graph.h Thu Nov 05 08:39:49 2009 +0100
@@ -21,7 +21,7 @@
///\ingroup graphs
///\file
-///\brief ListDigraph, ListGraph classes.
+///\brief ListDigraph and ListGraph classes.
#include <lemon/core.h>
#include <lemon/error.h>
@@ -32,6 +32,8 @@
namespace lemon {
+ class ListDigraph;
+
class ListDigraphBase {
protected:
@@ -62,6 +64,7 @@
class Node {
friend class ListDigraphBase;
+ friend class ListDigraph;
protected:
int id;
@@ -77,6 +80,7 @@
class Arc {
friend class ListDigraphBase;
+ friend class ListDigraph;
protected:
int id;
@@ -116,20 +120,20 @@
void first(Arc& arc) const {
int n;
for(n = first_node;
- n!=-1 && nodes[n].first_in == -1;
+ n != -1 && nodes[n].first_out == -1;
n = nodes[n].next) {}
- arc.id = (n == -1) ? -1 : nodes[n].first_in;
+ arc.id = (n == -1) ? -1 : nodes[n].first_out;
}
void next(Arc& arc) const {
- if (arcs[arc.id].next_in != -1) {
- arc.id = arcs[arc.id].next_in;
+ if (arcs[arc.id].next_out != -1) {
+ arc.id = arcs[arc.id].next_out;
} else {
int n;
- for(n = nodes[arcs[arc.id].target].next;
- n!=-1 && nodes[n].first_in == -1;
+ for(n = nodes[arcs[arc.id].source].next;
+ n != -1 && nodes[n].first_out == -1;
n = nodes[n].next) {}
- arc.id = (n == -1) ? -1 : nodes[n].first_in;
+ arc.id = (n == -1) ? -1 : nodes[n].first_out;
}
}
@@ -311,31 +315,25 @@
///A general directed graph structure.
- ///\ref ListDigraph is a simple and fast <em>directed graph</em>
- ///implementation based on static linked lists that are stored in
+ ///\ref ListDigraph is a versatile and fast directed graph
+ ///implementation based on linked lists that are stored in
///\c std::vector structures.
///
- ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
- ///also provides several useful additional functionalities.
- ///Most of the member functions and nested classes are documented
+ ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
+ ///and it also provides several useful additional functionalities.
+ ///Most of its member functions and nested classes are documented
///only in the concept class.
///
///\sa concepts::Digraph
-
+ ///\sa ListGraph
class ListDigraph : public ExtendedListDigraphBase {
typedef ExtendedListDigraphBase Parent;
private:
- ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
-
- ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
- ///
+ /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
- ///\brief Assignment of ListDigraph to another one is \e not allowed.
- ///Use copyDigraph() instead.
-
- ///Assignment of ListDigraph to another one is \e not allowed.
- ///Use copyDigraph() instead.
+ /// \brief Assignment of a digraph to another one is \e not allowed.
+ /// Use DigraphCopy instead.
void operator=(const ListDigraph &) {}
public:
@@ -347,71 +345,65 @@
///Add a new node to the digraph.
- ///Add a new node to the digraph.
+ ///This function adds a new node to the digraph.
///\return The new node.
Node addNode() { return Parent::addNode(); }
///Add a new arc to the digraph.
- ///Add a new arc to the digraph with source node \c s
+ ///This function adds a new arc to the digraph with source node \c s
///and target node \c t.
///\return The new arc.
- Arc addArc(const Node& s, const Node& t) {
+ Arc addArc(Node s, Node t) {
return Parent::addArc(s, t);
}
///\brief Erase a node from the digraph.
///
- ///Erase a node from the digraph.
- ///
- void erase(const Node& n) { Parent::erase(n); }
+ ///This function erases the given node from the digraph.
+ void erase(Node n) { Parent::erase(n); }
///\brief Erase an arc from the digraph.
///
- ///Erase an arc from the digraph.
- ///
- void erase(const Arc& a) { Parent::erase(a); }
+ ///This function erases the given arc from the digraph.
+ void erase(Arc a) { Parent::erase(a); }
/// Node validity check
- /// This function gives back true if the given node is valid,
- /// ie. it is a real node of the graph.
+ /// This function gives back \c true if the given node is valid,
+ /// i.e. it is a real node of the digraph.
///
- /// \warning A Node pointing to a removed item
- /// could become valid again later if new nodes are
- /// added to the graph.
+ /// \warning A removed node could become valid again if new nodes are
+ /// added to the digraph.
bool valid(Node n) const { return Parent::valid(n); }
/// Arc validity check
- /// This function gives back true if the given arc is valid,
- /// ie. it is a real arc of the graph.
+ /// This function gives back \c true if the given arc is valid,
+ /// i.e. it is a real arc of the digraph.
///
- /// \warning An Arc pointing to a removed item
- /// could become valid again later if new nodes are
- /// added to the graph.
+ /// \warning A removed arc could become valid again if new arcs are
+ /// added to the digraph.
bool valid(Arc a) const { return Parent::valid(a); }
- /// Change the target of \c a to \c n
+ /// Change the target node of an arc
- /// Change the target of \c a to \c n
+ /// This function changes the target node of the given arc \c a to \c n.
///
- ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
- ///the changed arc remain valid. However <tt>InArcIt</tt>s are
- ///invalidated.
+ ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
+ ///arc remain valid, however \c InArcIt iterators are invalidated.
///
///\warning This functionality cannot be used together with the Snapshot
///feature.
void changeTarget(Arc a, Node n) {
Parent::changeTarget(a,n);
}
- /// Change the source of \c a to \c n
+ /// Change the source node of an arc
- /// Change the source of \c a to \c n
+ /// This function changes the source node of the given arc \c a to \c n.
///
- ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
- ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
- ///invalidated.
+ ///\note \c InArcIt iterators referencing the changed arc remain
+ ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
///
///\warning This functionality cannot be used together with the Snapshot
///feature.
@@ -419,94 +411,76 @@
Parent::changeSource(a,n);
}
- /// Invert the direction of an arc.
+ /// Reverse the direction of an arc.
- ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
- ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
- ///invalidated.
+ /// This function reverses the direction of the given arc.
+ ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing
+ ///the changed arc are invalidated.
///
///\warning This functionality cannot be used together with the Snapshot
///feature.
- void reverseArc(Arc e) {
- Node t=target(e);
- changeTarget(e,source(e));
- changeSource(e,t);
+ void reverseArc(Arc a) {
+ Node t=target(a);
+ changeTarget(a,source(a));
+ changeSource(a,t);
}
- /// Reserve memory for nodes.
-
- /// Using this function it is possible to avoid the superfluous memory
- /// allocation: if you know that the digraph you want to build will
- /// be very large (e.g. it will contain millions of nodes and/or arcs)
- /// then it is worth reserving space for this amount before starting
- /// to build the digraph.
- /// \sa reserveArc
- void reserveNode(int n) { nodes.reserve(n); };
-
- /// Reserve memory for arcs.
-
- /// Using this function it is possible to avoid the superfluous memory
- /// allocation: if you know that the digraph you want to build will
- /// be very large (e.g. it will contain millions of nodes and/or arcs)
- /// then it is worth reserving space for this amount before starting
- /// to build the digraph.
- /// \sa reserveNode
- void reserveArc(int m) { arcs.reserve(m); };
-
///Contract two nodes.
- ///This function contracts two nodes.
- ///Node \p b will be removed but instead of deleting
- ///incident arcs, they will be joined to \p a.
- ///The last parameter \p r controls whether to remove loops. \c true
- ///means that loops will be removed.
+ ///This function contracts the given two nodes.
+ ///Node \c v is removed, but instead of deleting its
+ ///incident arcs, they are joined to node \c u.
+ ///If the last parameter \c r is \c true (this is the default value),
+ ///then the newly created loops are removed.
///
- ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
- ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
- ///may be invalidated.
+ ///\note The moved arcs are joined to node \c u using changeSource()
+ ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
+ ///invalidated for the outgoing arcs of node \c v and \c InArcIt
+ ///iterators are invalidated for the incomming arcs of \c v.
+ ///Moreover all iterators referencing node \c v or the removed
+ ///loops are also invalidated. Other iterators remain valid.
///
///\warning This functionality cannot be used together with the Snapshot
///feature.
- void contract(Node a, Node b, bool r = true)
+ void contract(Node u, Node v, bool r = true)
{
- for(OutArcIt e(*this,b);e!=INVALID;) {
+ for(OutArcIt e(*this,v);e!=INVALID;) {
OutArcIt f=e;
++f;
- if(r && target(e)==a) erase(e);
- else changeSource(e,a);
+ if(r && target(e)==u) erase(e);
+ else changeSource(e,u);
e=f;
}
- for(InArcIt e(*this,b);e!=INVALID;) {
+ for(InArcIt e(*this,v);e!=INVALID;) {
InArcIt f=e;
++f;
- if(r && source(e)==a) erase(e);
- else changeTarget(e,a);
+ if(r && source(e)==u) erase(e);
+ else changeTarget(e,u);
e=f;
}
- erase(b);
+ erase(v);
}
///Split a node.
- ///This function splits a node. First a new node is added to the digraph,
- ///then the source of each outgoing arc of \c n is moved to this new node.
- ///If \c connect is \c true (this is the default value), then a new arc
- ///from \c n to the newly created node is also added.
+ ///This function splits the given node. First, a new node is added
+ ///to the digraph, then the source of each outgoing arc of node \c n
+ ///is moved to this new node.
+ ///If the second parameter \c connect is \c true (this is the default
+ ///value), then a new arc from node \c n to the newly created node
+ ///is also added.
///\return The newly created node.
///
- ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
- ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
- ///be invalidated.
+ ///\note All iterators remain valid.
///
- ///\warning This functionality cannot be used in conjunction with the
+ ///\warning This functionality cannot be used together with the
///Snapshot feature.
Node split(Node n, bool connect = true) {
Node b = addNode();
- for(OutArcIt e(*this,n);e!=INVALID;) {
- OutArcIt f=e;
- ++f;
- changeSource(e,b);
- e=f;
+ nodes[b.id].first_out=nodes[n.id].first_out;
+ nodes[n.id].first_out=-1;
+ for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
+ arcs[i].source=b.id;
}
if (connect) addArc(n,b);
return b;
@@ -514,21 +488,52 @@
///Split an arc.
- ///This function splits an arc. First a new node \c b is added to
- ///the digraph, then the original arc is re-targeted to \c
- ///b. Finally an arc from \c b to the original target is added.
+ ///This function splits the given arc. First, a new node \c v is
+ ///added to the digraph, then the target node of the original arc
+ ///is set to \c v. Finally, an arc from \c v to the original target
+ ///is added.
+ ///\return The newly created node.
///
- ///\return The newly created node.
+ ///\note \c InArcIt iterators referencing the original arc are
+ ///invalidated. Other iterators remain valid.
///
///\warning This functionality cannot be used together with the
///Snapshot feature.
- Node split(Arc e) {
- Node b = addNode();
- addArc(b,target(e));
- changeTarget(e,b);
- return b;
+ Node split(Arc a) {
+ Node v = addNode();
+ addArc(v,target(a));
+ changeTarget(a,v);
+ return v;
}
+ ///Clear the digraph.
+
+ ///This function erases all nodes and arcs from the digraph.
+ ///
+ void clear() {
+ Parent::clear();
+ }
+
+ /// Reserve memory for nodes.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the digraph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or arcs),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the digraph.
+ /// \sa reserveArc()
+ void reserveNode(int n) { nodes.reserve(n); };
+
+ /// Reserve memory for arcs.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the digraph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or arcs),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the digraph.
+ /// \sa reserveNode()
+ void reserveArc(int m) { arcs.reserve(m); };
+
/// \brief Class to make a snapshot of the digraph and restore
/// it later.
///
@@ -537,9 +542,15 @@
/// The newly added nodes and arcs can be removed using the
/// restore() function.
///
- /// \warning Arc and node deletions and other modifications (e.g.
- /// contracting, splitting, reversing arcs or nodes) cannot be
+ /// \note After a state is restored, you cannot restore a later state,
+ /// i.e. you cannot add the removed nodes and arcs again using
+ /// another Snapshot instance.
+ ///
+ /// \warning Node and arc deletions and other modifications (e.g.
+ /// reversing, contracting, splitting arcs or nodes) cannot be
/// restored. These events invalidate the snapshot.
+ /// However the arcs and nodes that were added to the digraph after
+ /// making the current snapshot can be removed without invalidating it.
class Snapshot {
protected:
@@ -709,39 +720,40 @@
/// \brief Default constructor.
///
/// Default constructor.
- /// To actually make a snapshot you must call save().
+ /// You have to call save() to actually make a snapshot.
Snapshot()
: digraph(0), node_observer_proxy(*this),
arc_observer_proxy(*this) {}
/// \brief Constructor that immediately makes a snapshot.
///
- /// This constructor immediately makes a snapshot of the digraph.
- /// \param _digraph The digraph we make a snapshot of.
- Snapshot(ListDigraph &_digraph)
+ /// This constructor immediately makes a snapshot of the given digraph.
+ Snapshot(ListDigraph &gr)
: node_observer_proxy(*this),
arc_observer_proxy(*this) {
- attach(_digraph);
+ attach(gr);
}
/// \brief Make a snapshot.
///
- /// Make a snapshot of the digraph.
- ///
- /// This function can be called more than once. In case of a repeated
+ /// This function makes a snapshot of the given digraph.
+ /// It can be called more than once. In case of a repeated
/// call, the previous snapshot gets lost.
- /// \param _digraph The digraph we make the snapshot of.
- void save(ListDigraph &_digraph) {
+ void save(ListDigraph &gr) {
if (attached()) {
detach();
clear();
}
- attach(_digraph);
+ attach(gr);
}
/// \brief Undo the changes until the last snapshot.
- //
- /// Undo the changes until the last snapshot created by save().
+ ///
+ /// This function undos the changes until the last snapshot
+ /// created by save() or Snapshot(ListDigraph&).
+ ///
+ /// \warning This method invalidates the snapshot, i.e. repeated
+ /// restoring is not supported unless you call save() again.
void restore() {
detach();
for(std::list<Arc>::iterator it = added_arcs.begin();
@@ -755,9 +767,9 @@
clear();
}
- /// \brief Gives back true when the snapshot is valid.
+ /// \brief Returns \c true if the snapshot is valid.
///
- /// Gives back true when the snapshot is valid.
+ /// This function returns \c true if the snapshot is valid.
bool valid() const {
return attached();
}
@@ -795,10 +807,6 @@
typedef ListGraphBase Graph;
- class Node;
- class Arc;
- class Edge;
-
class Node {
friend class ListGraphBase;
protected:
@@ -848,8 +856,6 @@
bool operator<(const Arc& arc) const {return id < arc.id;}
};
-
-
ListGraphBase()
: nodes(), first_node(-1),
first_free_node(-1), arcs(), first_free_arc(-1) {}
@@ -1164,31 +1170,25 @@
///A general undirected graph structure.
- ///\ref ListGraph is a simple and fast <em>undirected graph</em>
- ///implementation based on static linked lists that are stored in
+ ///\ref ListGraph is a versatile and fast undirected graph
+ ///implementation based on linked lists that are stored in
///\c std::vector structures.
///
- ///It conforms to the \ref concepts::Graph "Graph concept" and it
- ///also provides several useful additional functionalities.
- ///Most of the member functions and nested classes are documented
+ ///This type fully conforms to the \ref concepts::Graph "Graph concept"
+ ///and it also provides several useful additional functionalities.
+ ///Most of its member functions and nested classes are documented
///only in the concept class.
///
///\sa concepts::Graph
-
+ ///\sa ListDigraph
class ListGraph : public ExtendedListGraphBase {
typedef ExtendedListGraphBase Parent;
private:
- ///ListGraph is \e not copy constructible. Use copyGraph() instead.
-
- ///ListGraph is \e not copy constructible. Use copyGraph() instead.
- ///
+ /// Graphs are \e not copy constructible. Use GraphCopy instead.
ListGraph(const ListGraph &) :ExtendedListGraphBase() {};
- ///\brief Assignment of ListGraph to another one is \e not allowed.
- ///Use copyGraph() instead.
-
- ///Assignment of ListGraph to another one is \e not allowed.
- ///Use copyGraph() instead.
+ /// \brief Assignment of a graph to another one is \e not allowed.
+ /// Use GraphCopy instead.
void operator=(const ListGraph &) {}
public:
/// Constructor
@@ -1201,94 +1201,95 @@
/// \brief Add a new node to the graph.
///
- /// Add a new node to the graph.
+ /// This function adds a new node to the graph.
/// \return The new node.
Node addNode() { return Parent::addNode(); }
/// \brief Add a new edge to the graph.
///
- /// Add a new edge to the graph with source node \c s
- /// and target node \c t.
+ /// This function adds a new edge to the graph between nodes
+ /// \c u and \c v with inherent orientation from node \c u to
+ /// node \c v.
/// \return The new edge.
- Edge addEdge(const Node& s, const Node& t) {
- return Parent::addEdge(s, t);
+ Edge addEdge(Node u, Node v) {
+ return Parent::addEdge(u, v);
}
- /// \brief Erase a node from the graph.
+ ///\brief Erase a node from the graph.
///
- /// Erase a node from the graph.
+ /// This function erases the given node from the graph.
+ void erase(Node n) { Parent::erase(n); }
+
+ ///\brief Erase an edge from the graph.
///
- void erase(const Node& n) { Parent::erase(n); }
-
- /// \brief Erase an edge from the graph.
- ///
- /// Erase an edge from the graph.
- ///
- void erase(const Edge& e) { Parent::erase(e); }
+ /// This function erases the given edge from the graph.
+ void erase(Edge e) { Parent::erase(e); }
/// Node validity check
- /// This function gives back true if the given node is valid,
- /// ie. it is a real node of the graph.
+ /// This function gives back \c true if the given node is valid,
+ /// i.e. it is a real node of the graph.
///
- /// \warning A Node pointing to a removed item
- /// could become valid again later if new nodes are
+ /// \warning A removed node could become valid again if new nodes are
/// added to the graph.
bool valid(Node n) const { return Parent::valid(n); }
+ /// Edge validity check
+
+ /// This function gives back \c true if the given edge is valid,
+ /// i.e. it is a real edge of the graph.
+ ///
+ /// \warning A removed edge could become valid again if new edges are
+ /// added to the graph.
+ bool valid(Edge e) const { return Parent::valid(e); }
/// Arc validity check
- /// This function gives back true if the given arc is valid,
- /// ie. it is a real arc of the graph.
+ /// This function gives back \c true if the given arc is valid,
+ /// i.e. it is a real arc of the graph.
///
- /// \warning An Arc pointing to a removed item
- /// could become valid again later if new edges are
+ /// \warning A removed arc could become valid again if new edges are
/// added to the graph.
bool valid(Arc a) const { return Parent::valid(a); }
- /// Edge validity check
- /// This function gives back true if the given edge is valid,
- /// ie. it is a real arc of the graph.
+ /// \brief Change the first node of an edge.
///
- /// \warning A Edge pointing to a removed item
- /// could become valid again later if new edges are
- /// added to the graph.
- bool valid(Edge e) const { return Parent::valid(e); }
- /// \brief Change the end \c u of \c e to \c n
+ /// This function changes the first node of the given edge \c e to \c n.
///
- /// This function changes the end \c u of \c e to node \c n.
- ///
- ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the
- ///changed edge are invalidated and if the changed node is the
- ///base node of an iterator then this iterator is also
- ///invalidated.
+ ///\note \c EdgeIt and \c ArcIt iterators referencing the
+ ///changed edge are invalidated and all other iterators whose
+ ///base node is the changed node are also invalidated.
///
///\warning This functionality cannot be used together with the
///Snapshot feature.
void changeU(Edge e, Node n) {
Parent::changeU(e,n);
}
- /// \brief Change the end \c v of \c e to \c n
+ /// \brief Change the second node of an edge.
///
- /// This function changes the end \c v of \c e to \c n.
+ /// This function changes the second node of the given edge \c e to \c n.
///
- ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain
- ///valid, however <tt>ArcIt</tt>s and if the changed node is the
- ///base node of an iterator then this iterator is invalidated.
+ ///\note \c EdgeIt iterators referencing the changed edge remain
+ ///valid, however \c ArcIt iterators referencing the changed edge and
+ ///all other iterators whose base node is the changed node are also
+ ///invalidated.
///
///\warning This functionality cannot be used together with the
///Snapshot feature.
void changeV(Edge e, Node n) {
Parent::changeV(e,n);
}
+
/// \brief Contract two nodes.
///
- /// This function contracts two nodes.
- /// Node \p b will be removed but instead of deleting
- /// its neighboring arcs, they will be joined to \p a.
- /// The last parameter \p r controls whether to remove loops. \c true
- /// means that loops will be removed.
+ /// This function contracts the given two nodes.
+ /// Node \c b is removed, but instead of deleting
+ /// its incident edges, they are joined to node \c a.
+ /// If the last parameter \c r is \c true (this is the default value),
+ /// then the newly created loops are removed.
///
- /// \note The <tt>ArcIt</tt>s referencing a moved arc remain
- /// valid.
+ /// \note The moved edges are joined to node \c a using changeU()
+ /// or changeV(), thus all edge and arc iterators whose base node is
+ /// \c b are invalidated.
+ /// Moreover all iterators referencing node \c b or the removed
+ /// loops are also invalidated. Other iterators remain valid.
///
///\warning This functionality cannot be used together with the
///Snapshot feature.
@@ -1307,6 +1308,33 @@
erase(b);
}
+ ///Clear the graph.
+
+ ///This function erases all nodes and arcs from the graph.
+ ///
+ void clear() {
+ Parent::clear();
+ }
+
+ /// Reserve memory for nodes.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the graph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or edges),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the graph.
+ /// \sa reserveEdge()
+ void reserveNode(int n) { nodes.reserve(n); };
+
+ /// Reserve memory for edges.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the graph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or edges),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the graph.
+ /// \sa reserveNode()
+ void reserveEdge(int m) { arcs.reserve(2 * m); };
/// \brief Class to make a snapshot of the graph and restore
/// it later.
@@ -1316,9 +1344,15 @@
/// The newly added nodes and edges can be removed
/// using the restore() function.
///
- /// \warning Edge and node deletions and other modifications
- /// (e.g. changing nodes of edges, contracting nodes) cannot be
- /// restored. These events invalidate the snapshot.
+ /// \note After a state is restored, you cannot restore a later state,
+ /// i.e. you cannot add the removed nodes and edges again using
+ /// another Snapshot instance.
+ ///
+ /// \warning Node and edge deletions and other modifications
+ /// (e.g. changing the end-nodes of edges or contracting nodes)
+ /// cannot be restored. These events invalidate the snapshot.
+ /// However the edges and nodes that were added to the graph after
+ /// making the current snapshot can be removed without invalidating it.
class Snapshot {
protected:
@@ -1488,39 +1522,40 @@
/// \brief Default constructor.
///
/// Default constructor.
- /// To actually make a snapshot you must call save().
+ /// You have to call save() to actually make a snapshot.
Snapshot()
: graph(0), node_observer_proxy(*this),
edge_observer_proxy(*this) {}
/// \brief Constructor that immediately makes a snapshot.
///
- /// This constructor immediately makes a snapshot of the graph.
- /// \param _graph The graph we make a snapshot of.
- Snapshot(ListGraph &_graph)
+ /// This constructor immediately makes a snapshot of the given graph.
+ Snapshot(ListGraph &gr)
: node_observer_proxy(*this),
edge_observer_proxy(*this) {
- attach(_graph);
+ attach(gr);
}
/// \brief Make a snapshot.
///
- /// Make a snapshot of the graph.
- ///
- /// This function can be called more than once. In case of a repeated
+ /// This function makes a snapshot of the given graph.
+ /// It can be called more than once. In case of a repeated
/// call, the previous snapshot gets lost.
- /// \param _graph The graph we make the snapshot of.
- void save(ListGraph &_graph) {
+ void save(ListGraph &gr) {
if (attached()) {
detach();
clear();
}
- attach(_graph);
+ attach(gr);
}
/// \brief Undo the changes until the last snapshot.
- //
- /// Undo the changes until the last snapshot created by save().
+ ///
+ /// This function undos the changes until the last snapshot
+ /// created by save() or Snapshot(ListGraph&).
+ ///
+ /// \warning This method invalidates the snapshot, i.e. repeated
+ /// restoring is not supported unless you call save() again.
void restore() {
detach();
for(std::list<Edge>::iterator it = added_edges.begin();
@@ -1534,9 +1569,9 @@
clear();
}
- /// \brief Gives back true when the snapshot is valid.
+ /// \brief Returns \c true if the snapshot is valid.
///
- /// Gives back true when the snapshot is valid.
+ /// This function returns \c true if the snapshot is valid.
bool valid() const {
return attached();
}
diff -r e746fb14e680 -r 432c54cec63c lemon/lp_base.h
--- a/lemon/lp_base.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/lp_base.h Thu Nov 05 08:39:49 2009 +0100
@@ -943,6 +943,14 @@
virtual int _addCol() = 0;
virtual int _addRow() = 0;
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
+ int row = _addRow();
+ _setRowCoeffs(row, b, e);
+ _setRowLowerBound(row, l);
+ _setRowUpperBound(row, u);
+ return row;
+ }
+
virtual void _eraseCol(int col) = 0;
virtual void _eraseRow(int row) = 0;
@@ -1207,8 +1215,10 @@
///\param u is the upper bound (\ref INF means no bound)
///\return The created row.
Row addRow(Value l,const Expr &e, Value u) {
- Row r=addRow();
- row(r,l,e,u);
+ Row r;
+ e.simplify();
+ r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
+ ExprIterator(e.comps.end(), cols), u - *e));
return r;
}
@@ -1217,8 +1227,12 @@
///\param c is a linear expression (see \ref Constr)
///\return The created row.
Row addRow(const Constr &c) {
- Row r=addRow();
- row(r,c);
+ Row r;
+ c.expr().simplify();
+ r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF,
+ ExprIterator(c.expr().comps.begin(), cols),
+ ExprIterator(c.expr().comps.end(), cols),
+ c.upperBounded()?c.upperBound():INF));
return r;
}
///Erase a column (i.e a variable) from the LP
diff -r e746fb14e680 -r 432c54cec63c lemon/lp_skeleton.cc
--- a/lemon/lp_skeleton.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/lp_skeleton.cc Thu Nov 05 08:39:49 2009 +0100
@@ -32,6 +32,11 @@
return ++row_num;
}
+ int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
+ {
+ return ++row_num;
+ }
+
void SkeletonSolverBase::_eraseCol(int) {}
void SkeletonSolverBase::_eraseRow(int) {}
diff -r e746fb14e680 -r 432c54cec63c lemon/lp_skeleton.h
--- a/lemon/lp_skeleton.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/lp_skeleton.h Thu Nov 05 08:39:49 2009 +0100
@@ -45,6 +45,8 @@
/// \e
virtual int _addRow();
/// \e
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
+ /// \e
virtual void _eraseCol(int i);
/// \e
virtual void _eraseRow(int i);
diff -r e746fb14e680 -r 432c54cec63c lemon/maps.h
--- a/lemon/maps.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/maps.h Thu Nov 05 08:39:49 2009 +0100
@@ -22,6 +22,7 @@
#include <iterator>
#include <functional>
#include <vector>
+#include <map>
#include <lemon/core.h>
@@ -29,8 +30,6 @@
///\ingroup maps
///\brief Miscellaneous property maps
-#include <map>
-
namespace lemon {
/// \addtogroup maps
@@ -57,7 +56,7 @@
/// its type definitions, or if you have to provide a writable map,
/// but data written to it is not required (i.e. it will be sent to
/// <tt>/dev/null</tt>).
- /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
///
/// \sa ConstMap
template<typename K, typename V>
@@ -90,7 +89,7 @@
/// value to each key.
///
/// In other aspects it is equivalent to \c NullMap.
- /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
+ /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
/// concept, but it absorbs the data written to it.
///
/// The simplest way of using this map is through the constMap()
@@ -159,7 +158,7 @@
/// value to each key.
///
/// In other aspects it is equivalent to \c NullMap.
- /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
+ /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
/// concept, but it absorbs the data written to it.
///
/// The simplest way of using this map is through the constMap()
@@ -233,7 +232,7 @@
/// values to integer keys from the range <tt>[0..size-1]</tt>.
/// It can be used with some data structures, for example
/// \c UnionFind, \c BinHeap, when the used items are small
- /// integers. This map conforms the \ref concepts::ReferenceMap
+ /// integers. This map conforms to the \ref concepts::ReferenceMap
/// "ReferenceMap" concept.
///
/// The simplest way of using this map is through the rangeMap()
@@ -341,7 +340,7 @@
/// that you can specify a default value for the keys that are not
/// stored actually. This value can be different from the default
/// contructed value (i.e. \c %Value()).
- /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
+ /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap"
/// concept.
///
/// This map is useful if a default value should be assigned to most of
@@ -707,7 +706,7 @@
/// "readable map" to another type using the default conversion.
/// The \c Key type of it is inherited from \c M and the \c Value
/// type is \c V.
- /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
+ /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
///
/// The simplest way of using this map is through the convertMap()
/// function.
@@ -1790,11 +1789,11 @@
/// order of Dfs algorithm, as the following examples show.
/// \code
/// std::vector<Node> v;
- /// dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();
+ /// dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);
/// \endcode
/// \code
/// std::vector<Node> v(countNodes(g));
- /// dfs(g,s).processedMap(loggerBoolMap(v.begin())).run();
+ /// dfs(g).processedMap(loggerBoolMap(v.begin())).run(s);
/// \endcode
///
/// \note The container of the iterator must contain enough space
@@ -1818,7 +1817,7 @@
/// \brief Provides an immutable and unique id for each item in a graph.
///
/// IdMap provides a unique and immutable id for each item of the
- /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
+ /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
/// - \b unique: different items get different ids,
/// - \b immutable: the id of an item does not change (even if you
/// delete other nodes).
@@ -1826,7 +1825,7 @@
/// Using this map you get access (i.e. can read) the inner id values of
/// the items stored in the graph, which is returned by the \c id()
/// function of the graph. This map can be inverted with its member
- /// class \c InverseMap or with the \c operator() member.
+ /// class \c InverseMap or with the \c operator()() member.
///
/// \tparam GR The graph type.
/// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
@@ -1866,9 +1865,11 @@
public:
- /// \brief This class represents the inverse of its owner (IdMap).
+ /// \brief The inverse map type of IdMap.
///
- /// This class represents the inverse of its owner (IdMap).
+ /// The inverse map type of IdMap. The subscript operator gives back
+ /// an item by its id.
+ /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
/// \see inverse()
class InverseMap {
public:
@@ -1883,9 +1884,9 @@
/// Constructor for creating an id-to-item map.
explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
- /// \brief Gives back the given item from its id.
+ /// \brief Gives back an item by its id.
///
- /// Gives back the given item from its id.
+ /// Gives back an item by its id.
Item operator[](int id) const { return _graph->fromId(id, Item());}
private:
@@ -1898,16 +1899,34 @@
InverseMap inverse() const { return InverseMap(*_graph);}
};
+ /// \brief Returns an \c IdMap class.
+ ///
+ /// This function just returns an \c IdMap class.
+ /// \relates IdMap
+ template <typename K, typename GR>
+ inline IdMap<GR, K> idMap(const GR& graph) {
+ return IdMap<GR, K>(graph);
+ }
/// \brief General cross reference graph map type.
/// This class provides simple invertable graph maps.
- /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
- /// and if a key is set to a new value then store it
- /// in the inverse map.
+ /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
+ /// and if a key is set to a new value, then stores it in the inverse map.
+ /// The graph items can be accessed by their values either using
+ /// \c InverseMap or \c operator()(), and the values of the map can be
+ /// accessed with an STL compatible forward iterator (\c ValueIt).
+ ///
+ /// This map is intended to be used when all associated values are
+ /// different (the map is actually invertable) or there are only a few
+ /// items with the same value.
+ /// Otherwise consider to use \c IterableValueMap, which is more
+ /// suitable and more efficient for such cases. It provides iterators
+ /// to traverse the items with the same associated value, however
+ /// it does not have \c InverseMap.
///
- /// The values of the map can be accessed
- /// with stl compatible forward iterator.
+ /// This type is not reference map, so it cannot be modified with
+ /// the subscript operator.
///
/// \tparam GR The graph type.
/// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
@@ -1923,7 +1942,7 @@
typedef typename ItemSetTraits<GR, K>::
template Map<V>::Type Map;
- typedef std::map<V, K> Container;
+ typedef std::multimap<V, K> Container;
Container _inv_map;
public:
@@ -1945,54 +1964,66 @@
/// \brief Forward iterator for values.
///
- /// This iterator is an stl compatible forward
+ /// This iterator is an STL compatible forward
/// iterator on the values of the map. The values can
/// be accessed in the <tt>[beginValue, endValue)</tt> range.
- class ValueIterator
+ /// They are considered with multiplicity, so each value is
+ /// traversed for each item it is assigned to.
+ class ValueIt
: public std::iterator<std::forward_iterator_tag, Value> {
friend class CrossRefMap;
private:
- ValueIterator(typename Container::const_iterator _it)
+ ValueIt(typename Container::const_iterator _it)
: it(_it) {}
public:
- ValueIterator() {}
-
- ValueIterator& operator++() { ++it; return *this; }
- ValueIterator operator++(int) {
- ValueIterator tmp(*this);
+ /// Constructor
+ ValueIt() {}
+
+ /// \e
+ ValueIt& operator++() { ++it; return *this; }
+ /// \e
+ ValueIt operator++(int) {
+ ValueIt tmp(*this);
operator++();
return tmp;
}
+ /// \e
const Value& operator*() const { return it->first; }
+ /// \e
const Value* operator->() const { return &(it->first); }
- bool operator==(ValueIterator jt) const { return it == jt.it; }
- bool operator!=(ValueIterator jt) const { return it != jt.it; }
+ /// \e
+ bool operator==(ValueIt jt) const { return it == jt.it; }
+ /// \e
+ bool operator!=(ValueIt jt) const { return it != jt.it; }
private:
typename Container::const_iterator it;
};
+
+ /// Alias for \c ValueIt
+ typedef ValueIt ValueIterator;
/// \brief Returns an iterator to the first value.
///
- /// Returns an stl compatible iterator to the
+ /// Returns an STL compatible iterator to the
/// first value of the map. The values of the
/// map can be accessed in the <tt>[beginValue, endValue)</tt>
/// range.
- ValueIterator beginValue() const {
- return ValueIterator(_inv_map.begin());
+ ValueIt beginValue() const {
+ return ValueIt(_inv_map.begin());
}
/// \brief Returns an iterator after the last value.
///
- /// Returns an stl compatible iterator after the
+ /// Returns an STL compatible iterator after the
/// last value of the map. The values of the
/// map can be accessed in the <tt>[beginValue, endValue)</tt>
/// range.
- ValueIterator endValue() const {
- return ValueIterator(_inv_map.end());
+ ValueIt endValue() const {
+ return ValueIt(_inv_map.end());
}
/// \brief Sets the value associated with the given key.
@@ -2000,11 +2031,15 @@
/// Sets the value associated with the given key.
void set(const Key& key, const Value& val) {
Value oldval = Map::operator[](key);
- typename Container::iterator it = _inv_map.find(oldval);
- if (it != _inv_map.end() && it->second == key) {
- _inv_map.erase(it);
+ typename Container::iterator it;
+ for (it = _inv_map.equal_range(oldval).first;
+ it != _inv_map.equal_range(oldval).second; ++it) {
+ if (it->second == key) {
+ _inv_map.erase(it);
+ break;
+ }
}
- _inv_map.insert(make_pair(val, key));
+ _inv_map.insert(std::make_pair(val, key));
Map::set(key, val);
}
@@ -2016,13 +2051,24 @@
return Map::operator[](key);
}
- /// \brief Gives back the item by its value.
+ /// \brief Gives back an item by its value.
///
- /// Gives back the item by its value.
- Key operator()(const Value& key) const {
- typename Container::const_iterator it = _inv_map.find(key);
+ /// This function gives back an item that is assigned to
+ /// the given value or \c INVALID if no such item exists.
+ /// If there are more items with the same associated value,
+ /// only one of them is returned.
+ Key operator()(const Value& val) const {
+ typename Container::const_iterator it = _inv_map.find(val);
return it != _inv_map.end() ? it->second : INVALID;
}
+
+ /// \brief Returns the number of items with the given value.
+ ///
+ /// This function returns the number of items with the given value
+ /// associated with it.
+ int count(const Value &val) const {
+ return _inv_map.count(val);
+ }
protected:
@@ -2032,9 +2078,13 @@
/// \c AlterationNotifier.
virtual void erase(const Key& key) {
Value val = Map::operator[](key);
- typename Container::iterator it = _inv_map.find(val);
- if (it != _inv_map.end() && it->second == key) {
- _inv_map.erase(it);
+ typename Container::iterator it;
+ for (it = _inv_map.equal_range(val).first;
+ it != _inv_map.equal_range(val).second; ++it) {
+ if (it->second == key) {
+ _inv_map.erase(it);
+ break;
+ }
}
Map::erase(key);
}
@@ -2046,9 +2096,13 @@
virtual void erase(const std::vector<Key>& keys) {
for (int i = 0; i < int(keys.size()); ++i) {
Value val = Map::operator[](keys[i]);
- typename Container::iterator it = _inv_map.find(val);
- if (it != _inv_map.end() && it->second == keys[i]) {
- _inv_map.erase(it);
+ typename Container::iterator it;
+ for (it = _inv_map.equal_range(val).first;
+ it != _inv_map.equal_range(val).second; ++it) {
+ if (it->second == keys[i]) {
+ _inv_map.erase(it);
+ break;
+ }
}
}
Map::erase(keys);
@@ -2065,10 +2119,12 @@
public:
- /// \brief The inverse map type.
+ /// \brief The inverse map type of CrossRefMap.
///
- /// The inverse of this map. The subscript operator of the map
- /// gives back the item that was last assigned to the value.
+ /// The inverse map type of CrossRefMap. The subscript operator gives
+ /// back an item by its value.
+ /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+ /// \see inverse()
class InverseMap {
public:
/// \brief Constructor
@@ -2084,8 +2140,9 @@
/// \brief Subscript operator.
///
- /// Subscript operator. It gives back the item
- /// that was last assigned to the given value.
+ /// Subscript operator. It gives back an item
+ /// that is assigned to the given value or \c INVALID
+ /// if no such item exists.
Value operator[](const Key& key) const {
return _inverted(key);
}
@@ -2094,20 +2151,20 @@
const CrossRefMap& _inverted;
};
- /// \brief It gives back the read-only inverse map.
+ /// \brief Gives back the inverse of the map.
///
- /// It gives back the read-only inverse map.
+ /// Gives back the inverse of the CrossRefMap.
InverseMap inverse() const {
return InverseMap(*this);
}
};
- /// \brief Provides continuous and unique ID for the
+ /// \brief Provides continuous and unique id for the
/// items of a graph.
///
/// RangeIdMap provides a unique and continuous
- /// ID for each item of a given type (\c Node, \c Arc or
+ /// id for each item of a given type (\c Node, \c Arc or
/// \c Edge) in a graph. This id is
/// - \b unique: different items get different ids,
/// - \b continuous: the range of the ids is the set of integers
@@ -2118,7 +2175,7 @@
/// Thus this id is not (necessarily) the same as what can get using
/// the \c id() function of the graph or \ref IdMap.
/// This map can be inverted with its member class \c InverseMap,
- /// or with the \c operator() member.
+ /// or with the \c operator()() member.
///
/// \tparam GR The graph type.
/// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
@@ -2246,16 +2303,16 @@
_inv_map[pi] = q;
}
- /// \brief Gives back the \e RangeId of the item
+ /// \brief Gives back the \e range \e id of the item
///
- /// Gives back the \e RangeId of the item.
+ /// Gives back the \e range \e id of the item.
int operator[](const Item& item) const {
return Map::operator[](item);
}
- /// \brief Gives back the item belonging to a \e RangeId
- ///
- /// Gives back the item belonging to a \e RangeId.
+ /// \brief Gives back the item belonging to a \e range \e id
+ ///
+ /// Gives back the item belonging to the given \e range \e id.
Item operator()(int id) const {
return _inv_map[id];
}
@@ -2269,7 +2326,9 @@
/// \brief The inverse map type of RangeIdMap.
///
- /// The inverse map type of RangeIdMap.
+ /// The inverse map type of RangeIdMap. The subscript operator gives
+ /// back an item by its \e range \e id.
+ /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
class InverseMap {
public:
/// \brief Constructor
@@ -2287,7 +2346,7 @@
/// \brief Subscript operator.
///
/// Subscript operator. It gives back the item
- /// that the descriptor currently belongs to.
+ /// that the given \e range \e id currently belongs to.
Value operator[](const Key& key) const {
return _inverted(key);
}
@@ -2305,12 +2364,932 @@
/// \brief Gives back the inverse of the map.
///
- /// Gives back the inverse of the map.
+ /// Gives back the inverse of the RangeIdMap.
const InverseMap inverse() const {
return InverseMap(*this);
}
};
+ /// \brief Returns a \c RangeIdMap class.
+ ///
+ /// This function just returns an \c RangeIdMap class.
+ /// \relates RangeIdMap
+ template <typename K, typename GR>
+ inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
+ return RangeIdMap<GR, K>(graph);
+ }
+
+ /// \brief Dynamic iterable \c bool map.
+ ///
+ /// This class provides a special graph map type which can store a
+ /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
+ /// For both \c true and \c false values it is possible to iterate on
+ /// the keys mapped to the value.
+ ///
+ /// This type is a reference map, so it can be modified with the
+ /// subscript operator.
+ ///
+ /// \tparam GR The graph type.
+ /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+ /// \c GR::Edge).
+ ///
+ /// \see IterableIntMap, IterableValueMap
+ /// \see CrossRefMap
+ template <typename GR, typename K>
+ class IterableBoolMap
+ : protected ItemSetTraits<GR, K>::template Map<int>::Type {
+ private:
+ typedef GR Graph;
+
+ typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;
+ typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;
+
+ std::vector<K> _array;
+ int _sep;
+
+ public:
+
+ /// Indicates that the map is reference map.
+ typedef True ReferenceMapTag;
+
+ /// The key type
+ typedef K Key;
+ /// The value type
+ typedef bool Value;
+ /// The const reference type.
+ typedef const Value& ConstReference;
+
+ private:
+
+ int position(const Key& key) const {
+ return Parent::operator[](key);
+ }
+
+ public:
+
+ /// \brief Reference to the value of the map.
+ ///
+ /// This class is similar to the \c bool type. It can be converted to
+ /// \c bool and it provides the same operators.
+ class Reference {
+ friend class IterableBoolMap;
+ private:
+ Reference(IterableBoolMap& map, const Key& key)
+ : _key(key), _map(map) {}
+ public:
+
+ Reference& operator=(const Reference& value) {
+ _map.set(_key, static_cast<bool>(value));
+ return *this;
+ }
+
+ operator bool() const {
+ return static_cast<const IterableBoolMap&>(_map)[_key];
+ }
+
+ Reference& operator=(bool value) {
+ _map.set(_key, value);
+ return *this;
+ }
+ Reference& operator&=(bool value) {
+ _map.set(_key, _map[_key] & value);
+ return *this;
+ }
+ Reference& operator|=(bool value) {
+ _map.set(_key, _map[_key] | value);
+ return *this;
+ }
+ Reference& operator^=(bool value) {
+ _map.set(_key, _map[_key] ^ value);
+ return *this;
+ }
+ private:
+ Key _key;
+ IterableBoolMap& _map;
+ };
+
+ /// \brief Constructor of the map with a default value.
+ ///
+ /// Constructor of the map with a default value.
+ explicit IterableBoolMap(const Graph& graph, bool def = false)
+ : Parent(graph) {
+ typename Parent::Notifier* nf = Parent::notifier();
+ Key it;
+ for (nf->first(it); it != INVALID; nf->next(it)) {
+ Parent::set(it, _array.size());
+ _array.push_back(it);
+ }
+ _sep = (def ? _array.size() : 0);
+ }
+
+ /// \brief Const subscript operator of the map.
+ ///
+ /// Const subscript operator of the map.
+ bool operator[](const Key& key) const {
+ return position(key) < _sep;
+ }
+
+ /// \brief Subscript operator of the map.
+ ///
+ /// Subscript operator of the map.
+ Reference operator[](const Key& key) {
+ return Reference(*this, key);
+ }
+
+ /// \brief Set operation of the map.
+ ///
+ /// Set operation of the map.
+ void set(const Key& key, bool value) {
+ int pos = position(key);
+ if (value) {
+ if (pos < _sep) return;
+ Key tmp = _array[_sep];
+ _array[_sep] = key;
+ Parent::set(key, _sep);
+ _array[pos] = tmp;
+ Parent::set(tmp, pos);
+ ++_sep;
+ } else {
+ if (pos >= _sep) return;
+ --_sep;
+ Key tmp = _array[_sep];
+ _array[_sep] = key;
+ Parent::set(key, _sep);
+ _array[pos] = tmp;
+ Parent::set(tmp, pos);
+ }
+ }
+
+ /// \brief Set all items.
+ ///
+ /// Set all items in the map.
+ /// \note Constant time operation.
+ void setAll(bool value) {
+ _sep = (value ? _array.size() : 0);
+ }
+
+ /// \brief Returns the number of the keys mapped to \c true.
+ ///
+ /// Returns the number of the keys mapped to \c true.
+ int trueNum() const {
+ return _sep;
+ }
+
+ /// \brief Returns the number of the keys mapped to \c false.
+ ///
+ /// Returns the number of the keys mapped to \c false.
+ int falseNum() const {
+ return _array.size() - _sep;
+ }
+
+ /// \brief Iterator for the keys mapped to \c true.
+ ///
+ /// Iterator for the keys mapped to \c true. It works
+ /// like a graph item iterator, it can be converted to
+ /// the key type of the map, incremented with \c ++ operator, and
+ /// if the iterator leaves the last valid key, it will be equal to
+ /// \c INVALID.
+ class TrueIt : public Key {
+ public:
+ typedef Key Parent;
+
+ /// \brief Creates an iterator.
+ ///
+ /// Creates an iterator. It iterates on the
+ /// keys mapped to \c true.
+ /// \param map The IterableBoolMap.
+ explicit TrueIt(const IterableBoolMap& map)
+ : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),
+ _map(&map) {}
+
+ /// \brief Invalid constructor \& conversion.
+ ///
+ /// This constructor initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ TrueIt(Invalid) : Parent(INVALID), _map(0) {}
+
+ /// \brief Increment operator.
+ ///
+ /// Increment operator.
+ TrueIt& operator++() {
+ int pos = _map->position(*this);
+ Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);
+ return *this;
+ }
+
+ private:
+ const IterableBoolMap* _map;
+ };
+
+ /// \brief Iterator for the keys mapped to \c false.
+ ///
+ /// Iterator for the keys mapped to \c false. It works
+ /// like a graph item iterator, it can be converted to
+ /// the key type of the map, incremented with \c ++ operator, and
+ /// if the iterator leaves the last valid key, it will be equal to
+ /// \c INVALID.
+ class FalseIt : public Key {
+ public:
+ typedef Key Parent;
+
+ /// \brief Creates an iterator.
+ ///
+ /// Creates an iterator. It iterates on the
+ /// keys mapped to \c false.
+ /// \param map The IterableBoolMap.
+ explicit FalseIt(const IterableBoolMap& map)
+ : Parent(map._sep < int(map._array.size()) ?
+ map._array.back() : INVALID), _map(&map) {}
+
+ /// \brief Invalid constructor \& conversion.
+ ///
+ /// This constructor initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ FalseIt(Invalid) : Parent(INVALID), _map(0) {}
+
+ /// \brief Increment operator.
+ ///
+ /// Increment operator.
+ FalseIt& operator++() {
+ int pos = _map->position(*this);
+ Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);
+ return *this;
+ }
+
+ private:
+ const IterableBoolMap* _map;
+ };
+
+ /// \brief Iterator for the keys mapped to a given value.
+ ///
+ /// Iterator for the keys mapped to a given value. It works
+ /// like a graph item iterator, it can be converted to
+ /// the key type of the map, incremented with \c ++ operator, and
+ /// if the iterator leaves the last valid key, it will be equal to
+ /// \c INVALID.
+ class ItemIt : public Key {
+ public:
+ typedef Key Parent;
+
+ /// \brief Creates an iterator with a value.
+ ///
+ /// Creates an iterator with a value. It iterates on the
+ /// keys mapped to the given value.
+ /// \param map The IterableBoolMap.
+ /// \param value The value.
+ ItemIt(const IterableBoolMap& map, bool value)
+ : Parent(value ?
+ (map._sep > 0 ?
+ map._array[map._sep - 1] : INVALID) :
+ (map._sep < int(map._array.size()) ?
+ map._array.back() : INVALID)), _map(&map) {}
+
+ /// \brief Invalid constructor \& conversion.
+ ///
+ /// This constructor initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ ItemIt(Invalid) : Parent(INVALID), _map(0) {}
+
+ /// \brief Increment operator.
+ ///
+ /// Increment operator.
+ ItemIt& operator++() {
+ int pos = _map->position(*this);
+ int _sep = pos >= _map->_sep ? _map->_sep : 0;
+ Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);
+ return *this;
+ }
+
+ private:
+ const IterableBoolMap* _map;
+ };
+
+ protected:
+
+ virtual void add(const Key& key) {
+ Parent::add(key);
+ Parent::set(key, _array.size());
+ _array.push_back(key);
+ }
+
+ virtual void add(const std::vector<Key>& keys) {
+ Parent::add(keys);
+ for (int i = 0; i < int(keys.size()); ++i) {
+ Parent::set(keys[i], _array.size());
+ _array.push_back(keys[i]);
+ }
+ }
+
+ virtual void erase(const Key& key) {
+ int pos = position(key);
+ if (pos < _sep) {
+ --_sep;
+ Parent::set(_array[_sep], pos);
+ _array[pos] = _array[_sep];
+ Parent::set(_array.back(), _sep);
+ _array[_sep] = _array.back();
+ _array.pop_back();
+ } else {
+ Parent::set(_array.back(), pos);
+ _array[pos] = _array.back();
+ _array.pop_back();
+ }
+ Parent::erase(key);
+ }
+
+ virtual void erase(const std::vector<Key>& keys) {
+ for (int i = 0; i < int(keys.size()); ++i) {
+ int pos = position(keys[i]);
+ if (pos < _sep) {
+ --_sep;
+ Parent::set(_array[_sep], pos);
+ _array[pos] = _array[_sep];
+ Parent::set(_array.back(), _sep);
+ _array[_sep] = _array.back();
+ _array.pop_back();
+ } else {
+ Parent::set(_array.back(), pos);
+ _array[pos] = _array.back();
+ _array.pop_back();
+ }
+ }
+ Parent::erase(keys);
+ }
+
+ virtual void build() {
+ Parent::build();
+ typename Parent::Notifier* nf = Parent::notifier();
+ Key it;
+ for (nf->first(it); it != INVALID; nf->next(it)) {
+ Parent::set(it, _array.size());
+ _array.push_back(it);
+ }
+ _sep = 0;
+ }
+
+ virtual void clear() {
+ _array.clear();
+ _sep = 0;
+ Parent::clear();
+ }
+
+ };
+
+
+ namespace _maps_bits {
+ template <typename Item>
+ struct IterableIntMapNode {
+ IterableIntMapNode() : value(-1) {}
+ IterableIntMapNode(int _value) : value(_value) {}
+ Item prev, next;
+ int value;
+ };
+ }
+
+ /// \brief Dynamic iterable integer map.
+ ///
+ /// This class provides a special graph map type which can store an
+ /// integer value for graph items (\c Node, \c Arc or \c Edge).
+ /// For each non-negative value it is possible to iterate on the keys
+ /// mapped to the value.
+ ///
+ /// This map is intended to be used with small integer values, for which
+ /// it is efficient, and supports iteration only for non-negative values.
+ /// If you need large values and/or iteration for negative integers,
+ /// consider to use \ref IterableValueMap instead.
+ ///
+ /// This type is a reference map, so it can be modified with the
+ /// subscript operator.
+ ///
+ /// \note The size of the data structure depends on the largest
+ /// value in the map.
+ ///
+ /// \tparam GR The graph type.
+ /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+ /// \c GR::Edge).
+ ///
+ /// \see IterableBoolMap, IterableValueMap
+ /// \see CrossRefMap
+ template <typename GR, typename K>
+ class IterableIntMap
+ : protected ItemSetTraits<GR, K>::
+ template Map<_maps_bits::IterableIntMapNode<K> >::Type {
+ public:
+ typedef typename ItemSetTraits<GR, K>::
+ template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;
+
+ /// The key type
+ typedef K Key;
+ /// The value type
+ typedef int Value;
+ /// The graph type
+ typedef GR Graph;
+
+ /// \brief Constructor of the map.
+ ///
+ /// Constructor of the map. It sets all values to -1.
+ explicit IterableIntMap(const Graph& graph)
+ : Parent(graph) {}
+
+ /// \brief Constructor of the map with a given value.
+ ///
+ /// Constructor of the map with a given value.
+ explicit IterableIntMap(const Graph& graph, int value)
+ : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {
+ if (value >= 0) {
+ for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
+ lace(it);
+ }
+ }
+ }
+
+ private:
+
+ void unlace(const Key& key) {
+ typename Parent::Value& node = Parent::operator[](key);
+ if (node.value < 0) return;
+ if (node.prev != INVALID) {
+ Parent::operator[](node.prev).next = node.next;
+ } else {
+ _first[node.value] = node.next;
+ }
+ if (node.next != INVALID) {
+ Parent::operator[](node.next).prev = node.prev;
+ }
+ while (!_first.empty() && _first.back() == INVALID) {
+ _first.pop_back();
+ }
+ }
+
+ void lace(const Key& key) {
+ typename Parent::Value& node = Parent::operator[](key);
+ if (node.value < 0) return;
+ if (node.value >= int(_first.size())) {
+ _first.resize(node.value + 1, INVALID);
+ }
+ node.prev = INVALID;
+ node.next = _first[node.value];
+ if (node.next != INVALID) {
+ Parent::operator[](node.next).prev = key;
+ }
+ _first[node.value] = key;
+ }
+
+ public:
+
+ /// Indicates that the map is reference map.
+ typedef True ReferenceMapTag;
+
+ /// \brief Reference to the value of the map.
+ ///
+ /// This class is similar to the \c int type. It can
+ /// be converted to \c int and it has the same operators.
+ class Reference {
+ friend class IterableIntMap;
+ private:
+ Reference(IterableIntMap& map, const Key& key)
+ : _key(key), _map(map) {}
+ public:
+
+ Reference& operator=(const Reference& value) {
+ _map.set(_key, static_cast<const int&>(value));
+ return *this;
+ }
+
+ operator const int&() const {
+ return static_cast<const IterableIntMap&>(_map)[_key];
+ }
+
+ Reference& operator=(int value) {
+ _map.set(_key, value);
+ return *this;
+ }
+ Reference& operator++() {
+ _map.set(_key, _map[_key] + 1);
+ return *this;
+ }
+ int operator++(int) {
+ int value = _map[_key];
+ _map.set(_key, value + 1);
+ return value;
+ }
+ Reference& operator--() {
+ _map.set(_key, _map[_key] - 1);
+ return *this;
+ }
+ int operator--(int) {
+ int value = _map[_key];
+ _map.set(_key, value - 1);
+ return value;
+ }
+ Reference& operator+=(int value) {
+ _map.set(_key, _map[_key] + value);
+ return *this;
+ }
+ Reference& operator-=(int value) {
+ _map.set(_key, _map[_key] - value);
+ return *this;
+ }
+ Reference& operator*=(int value) {
+ _map.set(_key, _map[_key] * value);
+ return *this;
+ }
+ Reference& operator/=(int value) {
+ _map.set(_key, _map[_key] / value);
+ return *this;
+ }
+ Reference& operator%=(int value) {
+ _map.set(_key, _map[_key] % value);
+ return *this;
+ }
+ Reference& operator&=(int value) {
+ _map.set(_key, _map[_key] & value);
+ return *this;
+ }
+ Reference& operator|=(int value) {
+ _map.set(_key, _map[_key] | value);
+ return *this;
+ }
+ Reference& operator^=(int value) {
+ _map.set(_key, _map[_key] ^ value);
+ return *this;
+ }
+ Reference& operator<<=(int value) {
+ _map.set(_key, _map[_key] << value);
+ return *this;
+ }
+ Reference& operator>>=(int value) {
+ _map.set(_key, _map[_key] >> value);
+ return *this;
+ }
+
+ private:
+ Key _key;
+ IterableIntMap& _map;
+ };
+
+ /// The const reference type.
+ typedef const Value& ConstReference;
+
+ /// \brief Gives back the maximal value plus one.
+ ///
+ /// Gives back the maximal value plus one.
+ int size() const {
+ return _first.size();
+ }
+
+ /// \brief Set operation of the map.
+ ///
+ /// Set operation of the map.
+ void set(const Key& key, const Value& value) {
+ unlace(key);
+ Parent::operator[](key).value = value;
+ lace(key);
+ }
+
+ /// \brief Const subscript operator of the map.
+ ///
+ /// Const subscript operator of the map.
+ const Value& operator[](const Key& key) const {
+ return Parent::operator[](key).value;
+ }
+
+ /// \brief Subscript operator of the map.
+ ///
+ /// Subscript operator of the map.
+ Reference operator[](const Key& key) {
+ return Reference(*this, key);
+ }
+
+ /// \brief Iterator for the keys with the same value.
+ ///
+ /// Iterator for the keys with the same value. It works
+ /// like a graph item iterator, it can be converted to
+ /// the item type of the map, incremented with \c ++ operator, and
+ /// if the iterator leaves the last valid item, it will be equal to
+ /// \c INVALID.
+ class ItemIt : public Key {
+ public:
+ typedef Key Parent;
+
+ /// \brief Invalid constructor \& conversion.
+ ///
+ /// This constructor initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ ItemIt(Invalid) : Parent(INVALID), _map(0) {}
+
+ /// \brief Creates an iterator with a value.
+ ///
+ /// Creates an iterator with a value. It iterates on the
+ /// keys mapped to the given value.
+ /// \param map The IterableIntMap.
+ /// \param value The value.
+ ItemIt(const IterableIntMap& map, int value) : _map(&map) {
+ if (value < 0 || value >= int(_map->_first.size())) {
+ Parent::operator=(INVALID);
+ } else {
+ Parent::operator=(_map->_first[value]);
+ }
+ }
+
+ /// \brief Increment operator.
+ ///
+ /// Increment operator.
+ ItemIt& operator++() {
+ Parent::operator=(_map->IterableIntMap::Parent::
+ operator[](static_cast<Parent&>(*this)).next);
+ return *this;
+ }
+
+ private:
+ const IterableIntMap* _map;
+ };
+
+ protected:
+
+ virtual void erase(const Key& key) {
+ unlace(key);
+ Parent::erase(key);
+ }
+
+ virtual void erase(const std::vector<Key>& keys) {
+ for (int i = 0; i < int(keys.size()); ++i) {
+ unlace(keys[i]);
+ }
+ Parent::erase(keys);
+ }
+
+ virtual void clear() {
+ _first.clear();
+ Parent::clear();
+ }
+
+ private:
+ std::vector<Key> _first;
+ };
+
+ namespace _maps_bits {
+ template <typename Item, typename Value>
+ struct IterableValueMapNode {
+ IterableValueMapNode(Value _value = Value()) : value(_value) {}
+ Item prev, next;
+ Value value;
+ };
+ }
+
+ /// \brief Dynamic iterable map for comparable values.
+ ///
+ /// This class provides a special graph map type which can store a
+ /// comparable value for graph items (\c Node, \c Arc or \c Edge).
+ /// For each value it is possible to iterate on the keys mapped to
+ /// the value (\c ItemIt), and the values of the map can be accessed
+ /// with an STL compatible forward iterator (\c ValueIt).
+ /// The map stores a linked list for each value, which contains
+ /// the items mapped to the value, and the used values are stored
+ /// in balanced binary tree (\c std::map).
+ ///
+ /// \ref IterableBoolMap and \ref IterableIntMap are similar classes
+ /// specialized for \c bool and \c int values, respectively.
+ ///
+ /// This type is not reference map, so it cannot be modified with
+ /// the subscript operator.
+ ///
+ /// \tparam GR The graph type.
+ /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+ /// \c GR::Edge).
+ /// \tparam V The value type of the map. It can be any comparable
+ /// value type.
+ ///
+ /// \see IterableBoolMap, IterableIntMap
+ /// \see CrossRefMap
+ template <typename GR, typename K, typename V>
+ class IterableValueMap
+ : protected ItemSetTraits<GR, K>::
+ template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {
+ public:
+ typedef typename ItemSetTraits<GR, K>::
+ template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;
+
+ /// The key type
+ typedef K Key;
+ /// The value type
+ typedef V Value;
+ /// The graph type
+ typedef GR Graph;
+
+ public:
+
+ /// \brief Constructor of the map with a given value.
+ ///
+ /// Constructor of the map with a given value.
+ explicit IterableValueMap(const Graph& graph,
+ const Value& value = Value())
+ : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {
+ for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
+ lace(it);
+ }
+ }
+
+ protected:
+
+ void unlace(const Key& key) {
+ typename Parent::Value& node = Parent::operator[](key);
+ if (node.prev != INVALID) {
+ Parent::operator[](node.prev).next = node.next;
+ } else {
+ if (node.next != INVALID) {
+ _first[node.value] = node.next;
+ } else {
+ _first.erase(node.value);
+ }
+ }
+ if (node.next != INVALID) {
+ Parent::operator[](node.next).prev = node.prev;
+ }
+ }
+
+ void lace(const Key& key) {
+ typename Parent::Value& node = Parent::operator[](key);
+ typename std::map<Value, Key>::iterator it = _first.find(node.value);
+ if (it == _first.end()) {
+ node.prev = node.next = INVALID;
+ _first.insert(std::make_pair(node.value, key));
+ } else {
+ node.prev = INVALID;
+ node.next = it->second;
+ if (node.next != INVALID) {
+ Parent::operator[](node.next).prev = key;
+ }
+ it->second = key;
+ }
+ }
+
+ public:
+
+ /// \brief Forward iterator for values.
+ ///
+ /// This iterator is an STL compatible forward
+ /// iterator on the values of the map. The values can
+ /// be accessed in the <tt>[beginValue, endValue)</tt> range.
+ class ValueIt
+ : public std::iterator<std::forward_iterator_tag, Value> {
+ friend class IterableValueMap;
+ private:
+ ValueIt(typename std::map<Value, Key>::const_iterator _it)
+ : it(_it) {}
+ public:
+
+ /// Constructor
+ ValueIt() {}
+
+ /// \e
+ ValueIt& operator++() { ++it; return *this; }
+ /// \e
+ ValueIt operator++(int) {
+ ValueIt tmp(*this);
+ operator++();
+ return tmp;
+ }
+
+ /// \e
+ const Value& operator*() const { return it->first; }
+ /// \e
+ const Value* operator->() const { return &(it->first); }
+
+ /// \e
+ bool operator==(ValueIt jt) const { return it == jt.it; }
+ /// \e
+ bool operator!=(ValueIt jt) const { return it != jt.it; }
+
+ private:
+ typename std::map<Value, Key>::const_iterator it;
+ };
+
+ /// \brief Returns an iterator to the first value.
+ ///
+ /// Returns an STL compatible iterator to the
+ /// first value of the map. The values of the
+ /// map can be accessed in the <tt>[beginValue, endValue)</tt>
+ /// range.
+ ValueIt beginValue() const {
+ return ValueIt(_first.begin());
+ }
+
+ /// \brief Returns an iterator after the last value.
+ ///
+ /// Returns an STL compatible iterator after the
+ /// last value of the map. The values of the
+ /// map can be accessed in the <tt>[beginValue, endValue)</tt>
+ /// range.
+ ValueIt endValue() const {
+ return ValueIt(_first.end());
+ }
+
+ /// \brief Set operation of the map.
+ ///
+ /// Set operation of the map.
+ void set(const Key& key, const Value& value) {
+ unlace(key);
+ Parent::operator[](key).value = value;
+ lace(key);
+ }
+
+ /// \brief Const subscript operator of the map.
+ ///
+ /// Const subscript operator of the map.
+ const Value& operator[](const Key& key) const {
+ return Parent::operator[](key).value;
+ }
+
+ /// \brief Iterator for the keys with the same value.
+ ///
+ /// Iterator for the keys with the same value. It works
+ /// like a graph item iterator, it can be converted to
+ /// the item type of the map, incremented with \c ++ operator, and
+ /// if the iterator leaves the last valid item, it will be equal to
+ /// \c INVALID.
+ class ItemIt : public Key {
+ public:
+ typedef Key Parent;
+
+ /// \brief Invalid constructor \& conversion.
+ ///
+ /// This constructor initializes the iterator to be invalid.
+ /// \sa Invalid for more details.
+ ItemIt(Invalid) : Parent(INVALID), _map(0) {}
+
+ /// \brief Creates an iterator with a value.
+ ///
+ /// Creates an iterator with a value. It iterates on the
+ /// keys which have the given value.
+ /// \param map The IterableValueMap
+ /// \param value The value
+ ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {
+ typename std::map<Value, Key>::const_iterator it =
+ map._first.find(value);
+ if (it == map._first.end()) {
+ Parent::operator=(INVALID);
+ } else {
+ Parent::operator=(it->second);
+ }
+ }
+
+ /// \brief Increment operator.
+ ///
+ /// Increment Operator.
+ ItemIt& operator++() {
+ Parent::operator=(_map->IterableValueMap::Parent::
+ operator[](static_cast<Parent&>(*this)).next);
+ return *this;
+ }
+
+
+ private:
+ const IterableValueMap* _map;
+ };
+
+ protected:
+
+ virtual void add(const Key& key) {
+ Parent::add(key);
+ unlace(key);
+ }
+
+ virtual void add(const std::vector<Key>& keys) {
+ Parent::add(keys);
+ for (int i = 0; i < int(keys.size()); ++i) {
+ lace(keys[i]);
+ }
+ }
+
+ virtual void erase(const Key& key) {
+ unlace(key);
+ Parent::erase(key);
+ }
+
+ virtual void erase(const std::vector<Key>& keys) {
+ for (int i = 0; i < int(keys.size()); ++i) {
+ unlace(keys[i]);
+ }
+ Parent::erase(keys);
+ }
+
+ virtual void build() {
+ Parent::build();
+ for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
+ lace(it);
+ }
+ }
+
+ virtual void clear() {
+ _first.clear();
+ Parent::clear();
+ }
+
+ private:
+ std::map<Value, Key> _first;
+ };
+
/// \brief Map of the source nodes of arcs in a digraph.
///
/// SourceMap provides access for the source node of each arc in a digraph,
@@ -2321,9 +3300,9 @@
class SourceMap {
public:
- ///\e
+ /// The key type (the \c Arc type of the digraph).
typedef typename GR::Arc Key;
- ///\e
+ /// The value type (the \c Node type of the digraph).
typedef typename GR::Node Value;
/// \brief Constructor
@@ -2362,9 +3341,9 @@
class TargetMap {
public:
- ///\e
+ /// The key type (the \c Arc type of the digraph).
typedef typename GR::Arc Key;
- ///\e
+ /// The value type (the \c Node type of the digraph).
typedef typename GR::Node Value;
/// \brief Constructor
@@ -2404,8 +3383,10 @@
class ForwardMap {
public:
+ /// The key type (the \c Edge type of the digraph).
+ typedef typename GR::Edge Key;
+ /// The value type (the \c Arc type of the digraph).
typedef typename GR::Arc Value;
- typedef typename GR::Edge Key;
/// \brief Constructor
///
@@ -2444,8 +3425,10 @@
class BackwardMap {
public:
+ /// The key type (the \c Edge type of the digraph).
+ typedef typename GR::Edge Key;
+ /// The value type (the \c Arc type of the digraph).
typedef typename GR::Arc Value;
- typedef typename GR::Edge Key;
/// \brief Constructor
///
@@ -2480,7 +3463,7 @@
/// in constant time. On the other hand, the values are updated automatically
/// whenever the digraph changes.
///
- /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+ /// \warning Besides \c addNode() and \c addArc(), a digraph structure
/// may provide alternative ways to modify the digraph.
/// The correct behavior of InDegMap is not guarantied if these additional
/// features are used. For example the functions
@@ -2496,7 +3479,7 @@
::ItemNotifier::ObserverBase {
public:
-
+
/// The graph type of InDegMap
typedef GR Graph;
typedef GR Digraph;
@@ -2610,7 +3593,7 @@
/// in constant time. On the other hand, the values are updated automatically
/// whenever the digraph changes.
///
- /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+ /// \warning Besides \c addNode() and \c addArc(), a digraph structure
/// may provide alternative ways to modify the digraph.
/// The correct behavior of OutDegMap is not guarantied if these additional
/// features are used. For example the functions
diff -r e746fb14e680 -r 432c54cec63c lemon/min_cost_arborescence.h
--- a/lemon/min_cost_arborescence.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/min_cost_arborescence.h Thu Nov 05 08:39:49 2009 +0100
@@ -488,8 +488,8 @@
/// \name Execution Control
/// The simplest way to execute the algorithm is to use
/// one of the member functions called \c run(...). \n
- /// If you need more control on the execution,
- /// first you must call \ref init(), then you can add several
+ /// 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 \ref start() will perform the arborescence
/// computation.
diff -r e746fb14e680 -r 432c54cec63c lemon/network_simplex.h
--- a/lemon/network_simplex.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/network_simplex.h Thu Nov 05 08:39:49 2009 +0100
@@ -40,7 +40,9 @@
/// for finding a \ref min_cost_flow "minimum cost flow".
///
/// \ref NetworkSimplex implements the primal Network Simplex algorithm
- /// for finding a \ref min_cost_flow "minimum cost flow".
+ /// for finding a \ref min_cost_flow "minimum cost flow"
+ /// \ref amo93networkflows, \ref dantzig63linearprog,
+ /// \ref kellyoneill91netsimplex.
/// This algorithm is a specialized version of the linear programming
/// simplex method directly for the minimum cost flow problem.
/// It is one of the most efficient solution methods.
@@ -161,8 +163,6 @@
TEMPLATE_DIGRAPH_TYPEDEFS(GR);
- typedef std::vector<Arc> ArcVector;
- typedef std::vector<Node> NodeVector;
typedef std::vector<int> IntVector;
typedef std::vector<bool> BoolVector;
typedef std::vector<Value> ValueVector;
@@ -364,33 +364,32 @@
bool findEnteringArc() {
Cost c, min = 0;
int cnt = _block_size;
- int e, min_arc = _next_arc;
+ int e;
for (e = _next_arc; e < _search_arc_num; ++e) {
c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
if (c < min) {
min = c;
- min_arc = e;
+ _in_arc = e;
}
if (--cnt == 0) {
- if (min < 0) break;
+ if (min < 0) goto search_end;
cnt = _block_size;
}
}
- if (min == 0 || cnt > 0) {
- for (e = 0; e < _next_arc; ++e) {
- c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
- if (c < min) {
- min = c;
- min_arc = e;
- }
- if (--cnt == 0) {
- if (min < 0) break;
- cnt = _block_size;
- }
+ for (e = 0; e < _next_arc; ++e) {
+ c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+ if (c < min) {
+ min = c;
+ _in_arc = e;
+ }
+ if (--cnt == 0) {
+ if (min < 0) goto search_end;
+ cnt = _block_size;
}
}
if (min >= 0) return false;
- _in_arc = min_arc;
+
+ search_end:
_next_arc = e;
return true;
}
@@ -428,7 +427,7 @@
_next_arc(0)
{
// The main parameters of the pivot rule
- const double LIST_LENGTH_FACTOR = 1.0;
+ const double LIST_LENGTH_FACTOR = 0.25;
const int MIN_LIST_LENGTH = 10;
const double MINOR_LIMIT_FACTOR = 0.1;
const int MIN_MINOR_LIMIT = 3;
@@ -445,7 +444,7 @@
/// Find next entering arc
bool findEnteringArc() {
Cost min, c;
- int e, min_arc = _next_arc;
+ int e;
if (_curr_length > 0 && _minor_count < _minor_limit) {
// Minor iteration: select the best eligible arc from the
// current candidate list
@@ -456,16 +455,13 @@
c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
if (c < min) {
min = c;
- min_arc = e;
+ _in_arc = e;
}
- if (c >= 0) {
+ else if (c >= 0) {
_candidates[i--] = _candidates[--_curr_length];
}
}
- if (min < 0) {
- _in_arc = min_arc;
- return true;
- }
+ if (min < 0) return true;
}
// Major iteration: build a new candidate list
@@ -477,27 +473,26 @@
_candidates[_curr_length++] = e;
if (c < min) {
min = c;
- min_arc = e;
+ _in_arc = e;
}
- if (_curr_length == _list_length) break;
+ if (_curr_length == _list_length) goto search_end;
}
}
- if (_curr_length < _list_length) {
- for (e = 0; e < _next_arc; ++e) {
- c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
- if (c < 0) {
- _candidates[_curr_length++] = e;
- if (c < min) {
- min = c;
- min_arc = e;
- }
- if (_curr_length == _list_length) break;
+ for (e = 0; e < _next_arc; ++e) {
+ c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+ if (c < 0) {
+ _candidates[_curr_length++] = e;
+ if (c < min) {
+ min = c;
+ _in_arc = e;
}
+ if (_curr_length == _list_length) goto search_end;
}
}
if (_curr_length == 0) return false;
+
+ search_end:
_minor_count = 1;
- _in_arc = min_arc;
_next_arc = e;
return true;
}
@@ -549,7 +544,7 @@
_next_arc(0), _cand_cost(ns._search_arc_num), _sort_func(_cand_cost)
{
// The main parameters of the pivot rule
- const double BLOCK_SIZE_FACTOR = 1.5;
+ const double BLOCK_SIZE_FACTOR = 1.0;
const int MIN_BLOCK_SIZE = 10;
const double HEAD_LENGTH_FACTOR = 0.1;
const int MIN_HEAD_LENGTH = 3;
@@ -578,39 +573,35 @@
// Extend the list
int cnt = _block_size;
- int last_arc = 0;
int limit = _head_length;
- for (int e = _next_arc; e < _search_arc_num; ++e) {
+ for (e = _next_arc; e < _search_arc_num; ++e) {
_cand_cost[e] = _state[e] *
(_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
if (_cand_cost[e] < 0) {
_candidates[_curr_length++] = e;
- last_arc = e;
}
if (--cnt == 0) {
- if (_curr_length > limit) break;
+ if (_curr_length > limit) goto search_end;
limit = 0;
cnt = _block_size;
}
}
- if (_curr_length <= limit) {
- for (int e = 0; e < _next_arc; ++e) {
- _cand_cost[e] = _state[e] *
- (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
- if (_cand_cost[e] < 0) {
- _candidates[_curr_length++] = e;
- last_arc = e;
- }
- if (--cnt == 0) {
- if (_curr_length > limit) break;
- limit = 0;
- cnt = _block_size;
- }
+ for (e = 0; e < _next_arc; ++e) {
+ _cand_cost[e] = _state[e] *
+ (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+ if (_cand_cost[e] < 0) {
+ _candidates[_curr_length++] = e;
+ }
+ if (--cnt == 0) {
+ if (_curr_length > limit) goto search_end;
+ limit = 0;
+ cnt = _block_size;
}
}
if (_curr_length == 0) return false;
- _next_arc = last_arc + 1;
+
+ search_end:
// Make heap of the candidate list (approximating a partial sort)
make_heap( _candidates.begin(), _candidates.begin() + _curr_length,
@@ -618,6 +609,7 @@
// Pop the first element of the heap
_in_arc = _candidates[0];
+ _next_arc = e;
pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
_sort_func );
_curr_length = std::min(_head_length, _curr_length - 1);
@@ -633,7 +625,11 @@
/// The constructor of the class.
///
/// \param graph The digraph the algorithm runs on.
- NetworkSimplex(const GR& graph) :
+ /// \param arc_mixing Indicate if the arcs have to be stored in a
+ /// mixed order in the internal data structure.
+ /// In special cases, it could lead to better overall performance,
+ /// but it is usually slower. Therefore it is disabled by default.
+ NetworkSimplex(const GR& graph, bool arc_mixing = false) :
_graph(graph), _node_id(graph), _arc_id(graph),
INF(std::numeric_limits<Value>::has_infinity ?
std::numeric_limits<Value>::infinity() :
@@ -671,31 +667,33 @@
_last_succ.resize(all_node_num);
_state.resize(max_arc_num);
- // Copy the graph (store the arcs in a mixed order)
+ // Copy the graph
int i = 0;
for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
_node_id[n] = i;
}
- int k = std::max(int(std::sqrt(double(_arc_num))), 10);
- i = 0;
- for (ArcIt a(_graph); a != INVALID; ++a) {
- _arc_id[a] = i;
- _source[i] = _node_id[_graph.source(a)];
- _target[i] = _node_id[_graph.target(a)];
- if ((i += k) >= _arc_num) i = (i % k) + 1;
+ if (arc_mixing) {
+ // Store the arcs in a mixed order
+ int k = std::max(int(std::sqrt(double(_arc_num))), 10);
+ int i = 0, j = 0;
+ for (ArcIt a(_graph); a != INVALID; ++a) {
+ _arc_id[a] = i;
+ _source[i] = _node_id[_graph.source(a)];
+ _target[i] = _node_id[_graph.target(a)];
+ if ((i += k) >= _arc_num) i = ++j;
+ }
+ } else {
+ // Store the arcs in the original order
+ int i = 0;
+ for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
+ _arc_id[a] = i;
+ _source[i] = _node_id[_graph.source(a)];
+ _target[i] = _node_id[_graph.target(a)];
+ }
}
- // Initialize maps
- for (int i = 0; i != _node_num; ++i) {
- _supply[i] = 0;
- }
- for (int i = 0; i != _arc_num; ++i) {
- _lower[i] = 0;
- _upper[i] = INF;
- _cost[i] = 1;
- }
- _have_lower = false;
- _stype = GEQ;
+ // Reset parameters
+ reset();
}
/// \name Parameters
@@ -768,7 +766,6 @@
/// This function sets the supply values of the nodes.
/// If neither this function nor \ref stSupply() is used before
/// calling \ref run(), the supply of each node will be set to zero.
- /// (It makes sense only if non-zero lower bounds are given.)
///
/// \param map A node map storing the supply values.
/// Its \c Value type must be convertible to the \c Value type
@@ -789,7 +786,6 @@
/// and the required flow value.
/// If neither this function nor \ref supplyMap() is used before
/// calling \ref run(), the supply of each node will be set to zero.
- /// (It makes sense only if non-zero lower bounds are given.)
///
/// Using this function has the same effect as using \ref supplyMap()
/// with such a map in which \c k is assigned to \c s, \c -k is
diff -r e746fb14e680 -r 432c54cec63c lemon/pairing_heap.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/pairing_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,474 @@
+/* -*- 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_PAIRING_HEAP_H
+#define LEMON_PAIRING_HEAP_H
+
+///\file
+///\ingroup heaps
+///\brief Pairing heap implementation.
+
+#include <vector>
+#include <utility>
+#include <functional>
+#include <lemon/math.h>
+
+namespace lemon {
+
+ /// \ingroup heaps
+ ///
+ ///\brief Pairing Heap.
+ ///
+ /// This class implements the \e pairing \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 pairing 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<PR>.
+#ifdef DOXYGEN
+ template <typename PR, typename IM, typename CMP>
+#else
+ template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
+ class PairingHeap {
+ 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 (<tt>-1</tt>) 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<store> _data;
+ int _min;
+ 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 (<tt>-1</tt>) for each item.
+ explicit PairingHeap(ItemIntMap &map)
+ : _min(0), _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 (<tt>-1</tt>) for each item.
+ /// \param comp The function object used for comparing the priorities.
+ PairingHeap(ItemIntMap &map, const Compare &comp)
+ : _min(0), _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;
+ }
+
+ /// \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;
+ _data.push_back(st);
+ i=s;
+ } else {
+ _data[i].parent=_data[i].child=-1;
+ _data[i].left_child=false;
+ _data[i].degree=0;
+ _data[i].in=true;
+ }
+
+ _data[i].prio=value;
+
+ if ( _num_items!=0 ) {
+ if ( _comp( value, _data[_min].prio) ) {
+ fuse(i,_min);
+ _min=i;
+ }
+ else fuse(_min,i);
+ }
+ else _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.
+ const 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() {
+ std::vector<int> trees;
+ int i=0, child_right = 0;
+ _data[_min].in=false;
+
+ if( -1!=_data[_min].child ) {
+ i=_data[_min].child;
+ trees.push_back(i);
+ _data[i].parent = -1;
+ _data[_min].child = -1;
+
+ int ch=-1;
+ while( _data[i].child!=-1 ) {
+ ch=_data[i].child;
+ if( _data[ch].left_child && i==_data[ch].parent ) {
+ break;
+ } else {
+ if( _data[ch].left_child ) {
+ child_right=_data[ch].parent;
+ _data[ch].parent = i;
+ --_data[i].degree;
+ }
+ else {
+ child_right=ch;
+ _data[i].child=-1;
+ _data[i].degree=0;
+ }
+ _data[child_right].parent = -1;
+ trees.push_back(child_right);
+ i = child_right;
+ }
+ }
+
+ int num_child = trees.size();
+ int other;
+ for( i=0; i<num_child-1; i+=2 ) {
+ if ( !_comp(_data[trees[i]].prio, _data[trees[i+1]].prio) ) {
+ other=trees[i];
+ trees[i]=trees[i+1];
+ trees[i+1]=other;
+ }
+ fuse( trees[i], trees[i+1] );
+ }
+
+ i = (0==(num_child % 2)) ? num_child-2 : num_child-1;
+ while(i>=2) {
+ if ( _comp(_data[trees[i]].prio, _data[trees[i-2]].prio) ) {
+ other=trees[i];
+ trees[i]=trees[i-2];
+ trees[i-2]=other;
+ }
+ fuse( trees[i-2], trees[i] );
+ i-=2;
+ }
+ _min = trees[0];
+ }
+ else {
+ _min = _data[_min].child;
+ }
+
+ if (_min >= 0) _data[_min].left_child = false;
+ --_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];
+ _data[i].prio=value;
+ int p=_data[i].parent;
+
+ if( _data[i].left_child && i!=_data[p].child ) {
+ p=_data[p].parent;
+ }
+
+ if ( p!=-1 && _comp(value,_data[p].prio) ) {
+ cut(i,p);
+ if ( _comp(_data[_min].prio,value) ) {
+ fuse(_min,i);
+ } else {
+ fuse(i,_min);
+ _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:
+
+ void cut(int a, int b) {
+ int child_a;
+ switch (_data[a].degree) {
+ case 2:
+ child_a = _data[_data[a].child].parent;
+ if( _data[a].left_child ) {
+ _data[child_a].left_child=true;
+ _data[b].child=child_a;
+ _data[child_a].parent=_data[a].parent;
+ }
+ else {
+ _data[child_a].left_child=false;
+ _data[child_a].parent=b;
+ if( a!=_data[b].child )
+ _data[_data[b].child].parent=child_a;
+ else
+ _data[b].child=child_a;
+ }
+ --_data[a].degree;
+ _data[_data[a].child].parent=a;
+ break;
+
+ case 1:
+ child_a = _data[a].child;
+ if( !_data[child_a].left_child ) {
+ --_data[a].degree;
+ if( _data[a].left_child ) {
+ _data[child_a].left_child=true;
+ _data[child_a].parent=_data[a].parent;
+ _data[b].child=child_a;
+ }
+ else {
+ _data[child_a].left_child=false;
+ _data[child_a].parent=b;
+ if( a!=_data[b].child )
+ _data[_data[b].child].parent=child_a;
+ else
+ _data[b].child=child_a;
+ }
+ _data[a].child=-1;
+ }
+ else {
+ --_data[b].degree;
+ if( _data[a].left_child ) {
+ _data[b].child =
+ (1==_data[b].degree) ? _data[a].parent : -1;
+ } else {
+ if (1==_data[b].degree)
+ _data[_data[b].child].parent=b;
+ else
+ _data[b].child=-1;
+ }
+ }
+ break;
+
+ case 0:
+ --_data[b].degree;
+ if( _data[a].left_child ) {
+ _data[b].child =
+ (0!=_data[b].degree) ? _data[a].parent : -1;
+ } else {
+ if( 0!=_data[b].degree )
+ _data[_data[b].child].parent=b;
+ else
+ _data[b].child=-1;
+ }
+ break;
+ }
+ _data[a].parent=-1;
+ _data[a].left_child=false;
+ }
+
+ void fuse(int a, int b) {
+ int child_a = _data[a].child;
+ int child_b = _data[b].child;
+ _data[a].child=b;
+ _data[b].parent=a;
+ _data[b].left_child=true;
+
+ if( -1!=child_a ) {
+ _data[b].child=child_a;
+ _data[child_a].parent=b;
+ _data[child_a].left_child=false;
+ ++_data[b].degree;
+
+ if( -1!=child_b ) {
+ _data[b].child=child_b;
+ _data[child_b].parent=child_a;
+ }
+ }
+ else { ++_data[a].degree; }
+ }
+
+ class store {
+ friend class PairingHeap;
+
+ Item name;
+ int parent;
+ int child;
+ bool left_child;
+ int degree;
+ bool in;
+ Prio prio;
+
+ store() : parent(-1), child(-1), left_child(false), degree(0), in(true) {}
+ };
+ };
+
+} //namespace lemon
+
+#endif //LEMON_PAIRING_HEAP_H
+
diff -r e746fb14e680 -r 432c54cec63c lemon/path.h
--- a/lemon/path.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/path.h Thu Nov 05 08:39:49 2009 +0100
@@ -1015,18 +1015,20 @@
/// \brief The source of a path
///
- /// This function returns the source of the given path.
+ /// This function returns the source node of the given path.
+ /// If the path is empty, then it returns \c INVALID.
template <typename Digraph, typename Path>
typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) {
- return digraph.source(path.front());
+ return path.empty() ? INVALID : digraph.source(path.front());
}
/// \brief The target of a path
///
- /// This function returns the target of the given path.
+ /// This function returns the target node of the given path.
+ /// If the path is empty, then it returns \c INVALID.
template <typename Digraph, typename Path>
typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {
- return digraph.target(path.back());
+ return path.empty() ? INVALID : digraph.target(path.back());
}
/// \brief Class which helps to iterate through the nodes of a path
diff -r e746fb14e680 -r 432c54cec63c lemon/preflow.h
--- a/lemon/preflow.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/preflow.h Thu Nov 05 08:39:49 2009 +0100
@@ -52,7 +52,11 @@
///
/// The type of the map that stores the flow values.
/// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+#ifdef DOXYGEN
+ typedef GR::ArcMap<Value> FlowMap;
+#else
typedef typename Digraph::template ArcMap<Value> FlowMap;
+#endif
/// \brief Instantiates a FlowMap.
///
@@ -67,9 +71,12 @@
///
/// The elevator type used by Preflow algorithm.
///
- /// \sa Elevator
- /// \sa LinkedElevator
- typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
+ /// \sa Elevator, LinkedElevator
+#ifdef DOXYGEN
+ typedef lemon::Elevator<GR, GR::Node> Elevator;
+#else
+ typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
+#endif
/// \brief Instantiates an Elevator.
///
@@ -95,9 +102,10 @@
///
/// This class provides an implementation of Goldberg-Tarjan's \e preflow
/// \e push-relabel algorithm producing a \ref max_flow
- /// "flow of maximum value" in a digraph.
+ /// "flow of maximum value" in a digraph \ref clrs01algorithms,
+ /// \ref amo93networkflows, \ref goldberg88newapproach.
/// The preflow algorithms are the fastest known maximum
- /// flow algorithms. The current implementation use a mixture of the
+ /// flow algorithms. The current implementation uses a mixture of the
/// \e "highest label" and the \e "bound decrease" heuristics.
/// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
///
@@ -371,26 +379,28 @@
return *_level;
}
- /// \brief Sets the tolerance used by algorithm.
+ /// \brief Sets the tolerance used by the algorithm.
///
- /// Sets the tolerance used by algorithm.
- Preflow& tolerance(const Tolerance& tolerance) const {
+ /// Sets the tolerance object used by the algorithm.
+ /// \return <tt>(*this)</tt>
+ Preflow& tolerance(const Tolerance& tolerance) {
_tolerance = tolerance;
return *this;
}
/// \brief Returns a const reference to the tolerance.
///
- /// Returns a const reference to the tolerance.
+ /// Returns a const reference to the tolerance object used by
+ /// the algorithm.
const Tolerance& tolerance() const {
- return tolerance;
+ return _tolerance;
}
/// \name Execution Control
/// The simplest way to execute the preflow algorithm is to use
/// \ref run() or \ref runMinCut().\n
- /// If you need more control on the initial solution or the execution,
- /// first you have to call one of the \ref init() functions, then
+ /// If you need better control on the initial solution or the execution,
+ /// you have to call one of the \ref init() functions first, then
/// \ref startFirstPhase() and if you need it \ref startSecondPhase().
///@{
diff -r e746fb14e680 -r 432c54cec63c lemon/radix_heap.h
--- a/lemon/radix_heap.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/radix_heap.h Thu Nov 05 08:39:49 2009 +0100
@@ -19,9 +19,9 @@
#ifndef LEMON_RADIX_HEAP_H
#define LEMON_RADIX_HEAP_H
-///\ingroup auxdat
+///\ingroup heaps
///\file
-///\brief Radix Heap implementation.
+///\brief Radix heap implementation.
#include <vector>
#include <lemon/error.h>
@@ -29,56 +29,54 @@
namespace lemon {
- /// \ingroup auxdata
+ /// \ingroup heaps
///
- /// \brief A Radix Heap implementation.
+ /// \brief Radix heap data structure.
///
- /// This class implements the \e radix \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. This heap type can store only items with \e int priority.
- /// In a heap one can change the priority of an item, add or erase an
- /// item, but the priority cannot be decreased under the last removed
- /// item's priority.
+ /// This class implements the \e radix \e heap data structure.
+ /// It practically conforms to the \ref concepts::Heap "heap concept",
+ /// but it has some limitations due its special implementation.
+ /// The type of the priorities must be \c int and the priority of an
+ /// item cannot be decreased under the priority of the last removed item.
///
- /// \param IM A read and writable Item int map, used internally
- /// to handle the cross references.
- ///
- /// \see BinHeap
- /// \see Dijkstra
+ /// \tparam IM A read-writable item map with \c int values, used
+ /// internally to handle the cross references.
template <typename IM>
class RadixHeap {
public:
- typedef typename IM::Key Item;
+
+ /// Type of the item-int map.
+ typedef IM ItemIntMap;
+ /// Type of the priorities.
typedef int Prio;
- typedef IM ItemIntMap;
+ /// Type of the items stored in the heap.
+ typedef typename ItemIntMap::Key Item;
/// \brief Exception thrown by RadixHeap.
///
- /// This Exception is thrown when a smaller priority
- /// is inserted into the \e RadixHeap then the last time erased.
+ /// This exception is thrown when an item is inserted into a
+ /// RadixHeap with a priority smaller than the last erased one.
/// \see RadixHeap
-
- class UnderFlowPriorityError : public Exception {
+ class PriorityUnderflowError : public Exception {
public:
virtual const char* what() const throw() {
- return "lemon::RadixHeap::UnderFlowPriorityError";
+ return "lemon::RadixHeap::PriorityUnderflowError";
}
};
- /// \brief Type to represent the items states.
+ /// \brief Type to represent the states of the items.
///
- /// 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
+ /// 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 ItemIntMap \e should be initialized in such way that it maps
- /// PRE_HEAP (-1) to any element to be put in the heap...
+ /// The item-int map must be initialized in such way that it assigns
+ /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
enum State {
- IN_HEAP = 0,
- PRE_HEAP = -1,
- POST_HEAP = -2
+ IN_HEAP = 0, ///< = 0.
+ PRE_HEAP = -1, ///< = -1.
+ POST_HEAP = -2 ///< = -2.
};
private:
@@ -96,52 +94,55 @@
RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {}
};
- std::vector<RadixItem> data;
- std::vector<RadixBox> boxes;
+ std::vector<RadixItem> _data;
+ std::vector<RadixBox> _boxes;
ItemIntMap &_iim;
+ public:
- public:
- /// \brief The constructor.
+ /// \brief Constructor.
///
- /// The constructor.
- ///
- /// \param map It 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 minimal The initial minimal value of the heap.
- /// \param capacity It determines the initial capacity of the heap.
- RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0)
- : _iim(map) {
- boxes.push_back(RadixBox(minimal, 1));
- boxes.push_back(RadixBox(minimal + 1, 1));
- while (lower(boxes.size() - 1, capacity + minimal - 1)) {
+ /// 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 (<tt>-1</tt>) for each item.
+ /// \param minimum The initial minimum value of the heap.
+ /// \param capacity The initial capacity of the heap.
+ RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)
+ : _iim(map)
+ {
+ _boxes.push_back(RadixBox(minimum, 1));
+ _boxes.push_back(RadixBox(minimum + 1, 1));
+ while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
extend();
}
}
- /// The number of items stored in the heap.
+ /// \brief 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 Checks if the heap stores no items.
+ /// This function returns the number of items stored in the heap.
+ int size() const { return _data.size(); }
+
+ /// \brief Check if the heap is empty.
///
- /// Returns \c true if and only if the heap stores no items.
- bool empty() const { return data.empty(); }
+ /// This function returns \c true if the heap is empty.
+ bool empty() const { return _data.empty(); }
- /// \brief Make empty this heap.
+ /// \brief Make the heap empty.
///
- /// 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(int minimal = 0, int capacity = 0) {
- data.clear(); boxes.clear();
- boxes.push_back(RadixBox(minimal, 1));
- boxes.push_back(RadixBox(minimal + 1, 1));
- while (lower(boxes.size() - 1, capacity + minimal - 1)) {
+ /// 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.
+ /// \param minimum The minimum value of the heap.
+ /// \param capacity The capacity of the heap.
+ void clear(int minimum = 0, int capacity = 0) {
+ _data.clear(); _boxes.clear();
+ _boxes.push_back(RadixBox(minimum, 1));
+ _boxes.push_back(RadixBox(minimum + 1, 1));
+ while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
extend();
}
}
@@ -149,255 +150,259 @@
private:
bool upper(int box, Prio pr) {
- return pr < boxes[box].min;
+ return pr < _boxes[box].min;
}
bool lower(int box, Prio pr) {
- return pr >= boxes[box].min + boxes[box].size;
+ return pr >= _boxes[box].min + _boxes[box].size;
}
- /// \brief Remove item from the box list.
+ // Remove item from the box list
void remove(int index) {
- if (data[index].prev >= 0) {
- data[data[index].prev].next = data[index].next;
+ if (_data[index].prev >= 0) {
+ _data[_data[index].prev].next = _data[index].next;
} else {
- boxes[data[index].box].first = data[index].next;
+ _boxes[_data[index].box].first = _data[index].next;
}
- if (data[index].next >= 0) {
- data[data[index].next].prev = data[index].prev;
+ if (_data[index].next >= 0) {
+ _data[_data[index].next].prev = _data[index].prev;
}
}
- /// \brief Insert item into the box list.
+ // Insert item into the box list
void insert(int box, int index) {
- if (boxes[box].first == -1) {
- boxes[box].first = index;
- data[index].next = data[index].prev = -1;
+ if (_boxes[box].first == -1) {
+ _boxes[box].first = index;
+ _data[index].next = _data[index].prev = -1;
} else {
- data[index].next = boxes[box].first;
- data[boxes[box].first].prev = index;
- data[index].prev = -1;
- boxes[box].first = index;
+ _data[index].next = _boxes[box].first;
+ _data[_boxes[box].first].prev = index;
+ _data[index].prev = -1;
+ _boxes[box].first = index;
}
- data[index].box = box;
+ _data[index].box = box;
}
- /// \brief Add a new box to the box list.
+ // Add a new box to the box list
void extend() {
- int min = boxes.back().min + boxes.back().size;
- int bs = 2 * boxes.back().size;
- boxes.push_back(RadixBox(min, bs));
+ int min = _boxes.back().min + _boxes.back().size;
+ int bs = 2 * _boxes.back().size;
+ _boxes.push_back(RadixBox(min, bs));
}
- /// \brief Move an item up into the proper box.
- void bubble_up(int index) {
- if (!lower(data[index].box, data[index].prio)) return;
+ // Move an item up into the proper box.
+ void bubbleUp(int index) {
+ if (!lower(_data[index].box, _data[index].prio)) return;
remove(index);
- int box = findUp(data[index].box, data[index].prio);
+ int box = findUp(_data[index].box, _data[index].prio);
insert(box, index);
}
- /// \brief Find up the proper box for the item with the given prio.
+ // Find up the proper box for the item with the given priority
int findUp(int start, int pr) {
while (lower(start, pr)) {
- if (++start == int(boxes.size())) {
+ if (++start == int(_boxes.size())) {
extend();
}
}
return start;
}
- /// \brief Move an item down into the proper box.
- void bubble_down(int index) {
- if (!upper(data[index].box, data[index].prio)) return;
+ // Move an item down into the proper box
+ void bubbleDown(int index) {
+ if (!upper(_data[index].box, _data[index].prio)) return;
remove(index);
- int box = findDown(data[index].box, data[index].prio);
+ int box = findDown(_data[index].box, _data[index].prio);
insert(box, index);
}
- /// \brief Find up the proper box for the item with the given prio.
+ // Find down the proper box for the item with the given priority
int findDown(int start, int pr) {
while (upper(start, pr)) {
- if (--start < 0) throw UnderFlowPriorityError();
+ if (--start < 0) throw PriorityUnderflowError();
}
return start;
}
- /// \brief Find the first not empty box.
+ // Find the first non-empty box
int findFirst() {
int first = 0;
- while (boxes[first].first == -1) ++first;
+ while (_boxes[first].first == -1) ++first;
return first;
}
- /// \brief Gives back the minimal prio of the box.
+ // Gives back the minimum priority of the given box
int minValue(int box) {
- int min = data[boxes[box].first].prio;
- for (int k = boxes[box].first; k != -1; k = data[k].next) {
- if (data[k].prio < min) min = data[k].prio;
+ int min = _data[_boxes[box].first].prio;
+ for (int k = _boxes[box].first; k != -1; k = _data[k].next) {
+ if (_data[k].prio < min) min = _data[k].prio;
}
return min;
}
- /// \brief Rearrange the items of the heap and makes the
- /// first box not empty.
+ // Rearrange the items of the heap and make the first box non-empty
void moveDown() {
int box = findFirst();
if (box == 0) return;
int min = minValue(box);
for (int i = 0; i <= box; ++i) {
- boxes[i].min = min;
- min += boxes[i].size;
+ _boxes[i].min = min;
+ min += _boxes[i].size;
}
- int curr = boxes[box].first, next;
+ int curr = _boxes[box].first, next;
while (curr != -1) {
- next = data[curr].next;
- bubble_down(curr);
+ next = _data[curr].next;
+ bubbleDown(curr);
curr = next;
}
}
- void relocate_last(int index) {
- if (index != int(data.size()) - 1) {
- data[index] = data.back();
- if (data[index].prev != -1) {
- data[data[index].prev].next = index;
+ void relocateLast(int index) {
+ if (index != int(_data.size()) - 1) {
+ _data[index] = _data.back();
+ if (_data[index].prev != -1) {
+ _data[_data[index].prev].next = index;
} else {
- boxes[data[index].box].first = index;
+ _boxes[_data[index].box].first = index;
}
- if (data[index].next != -1) {
- data[data[index].next].prev = index;
+ if (_data[index].next != -1) {
+ _data[_data[index].next].prev = index;
}
- _iim[data[index].item] = index;
+ _iim[_data[index].item] = index;
}
- data.pop_back();
+ _data.pop_back();
}
public:
/// \brief Insert an item into the heap with the given priority.
///
- /// Adds \c i to the heap with priority \c p.
+ /// This function inserts the given item into the heap with the
+ /// given priority.
/// \param i The item to insert.
/// \param p The priority of the item.
+ /// \pre \e i must not be stored in the heap.
+ /// \warning This method may throw an \c UnderFlowPriorityException.
void push(const Item &i, const Prio &p) {
- int n = data.size();
+ int n = _data.size();
_iim.set(i, n);
- data.push_back(RadixItem(i, p));
- while (lower(boxes.size() - 1, p)) {
+ _data.push_back(RadixItem(i, p));
+ while (lower(_boxes.size() - 1, p)) {
extend();
}
- int box = findDown(boxes.size() - 1, p);
+ int box = findDown(_boxes.size() - 1, p);
insert(box, n);
}
- /// \brief Returns the item with minimum priority.
+ /// \brief Return the item having minimum priority.
///
- /// This method returns the item with minimum priority.
- /// \pre The heap must be nonempty.
+ /// This function returns the item having minimum priority.
+ /// \pre The heap must be non-empty.
Item top() const {
const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
- return data[boxes[0].first].item;
+ return _data[_boxes[0].first].item;
}
- /// \brief Returns the minimum priority.
+ /// \brief The minimum priority.
///
- /// It returns the minimum priority.
- /// \pre The heap must be nonempty.
+ /// This function returns the minimum priority.
+ /// \pre The heap must be non-empty.
Prio prio() const {
const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
- return data[boxes[0].first].prio;
+ return _data[_boxes[0].first].prio;
}
- /// \brief Deletes the item with minimum priority.
+ /// \brief Remove the item having minimum priority.
///
- /// This method deletes the item with minimum priority.
+ /// This function removes the item having minimum priority.
/// \pre The heap must be non-empty.
void pop() {
moveDown();
- int index = boxes[0].first;
- _iim[data[index].item] = POST_HEAP;
+ int index = _boxes[0].first;
+ _iim[_data[index].item] = POST_HEAP;
remove(index);
- relocate_last(index);
+ relocateLast(index);
}
- /// \brief Deletes \c i from the heap.
+ /// \brief Remove the given item 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.
+ /// 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 index = _iim[i];
_iim[i] = POST_HEAP;
remove(index);
- relocate_last(index);
+ relocateLast(index);
}
- /// \brief Returns the priority of \c i.
+ /// \brief The priority of the given item.
///
- /// This function returns the priority of item \c i.
- /// \pre \c i must be in the heap.
+ /// This function returns the priority of the given item.
/// \param i The item.
+ /// \pre \e i must be in the heap.
Prio operator[](const Item &i) const {
int idx = _iim[i];
- return data[idx].prio;
+ return _data[idx].prio;
}
- /// \brief \c i gets to the heap with priority \c p independently
- /// if \c i was already there.
+ /// \brief Set the priority of an item or insert it, if it is
+ /// not stored in the heap.
///
- /// 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.
- /// It may throw an \e UnderFlowPriorityException.
+ /// This method sets the priority of the given item if it is
+ /// already stored in the heap. Otherwise it inserts the given
+ /// item into the heap with the given priority.
/// \param i The item.
/// \param p The priority.
+ /// \pre \e i must be in the heap.
+ /// \warning This method may throw an \c UnderFlowPriorityException.
void set(const Item &i, const Prio &p) {
int idx = _iim[i];
if( idx < 0 ) {
push(i, p);
}
- else if( p >= data[idx].prio ) {
- data[idx].prio = p;
- bubble_up(idx);
+ else if( p >= _data[idx].prio ) {
+ _data[idx].prio = p;
+ bubbleUp(idx);
} else {
- data[idx].prio = p;
- bubble_down(idx);
+ _data[idx].prio = p;
+ bubbleDown(idx);
}
}
-
- /// \brief Decreases the priority of \c i to \c p.
+ /// \brief Decrease the priority of an item to the given value.
///
- /// 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, and
- /// \c should be greater or equal to the last removed item's priority.
+ /// This function decreases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
+ /// \pre \e i must be stored in the heap with priority at least \e p.
+ /// \warning This method may throw an \c UnderFlowPriorityException.
void decrease(const Item &i, const Prio &p) {
int idx = _iim[i];
- data[idx].prio = p;
- bubble_down(idx);
+ _data[idx].prio = p;
+ bubbleDown(idx);
}
- /// \brief Increases the priority of \c i to \c p.
+ /// \brief Increase the priority of an item to the given value.
///
- /// 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
+ /// This function increases the priority of an item to the given value.
/// \param i The item.
/// \param p The priority.
+ /// \pre \e i must be stored in the heap with priority at most \e p.
void increase(const Item &i, const Prio &p) {
int idx = _iim[i];
- data[idx].prio = p;
- bubble_up(idx);
+ _data[idx].prio = p;
+ bubbleUp(idx);
}
- /// \brief Returns if \c item is in, has already been in, or has
- /// never been in the heap.
+ /// \brief Return the state of an item.
///
- /// 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.
+ /// This method returns \c PRE_HEAP if the given item has never
+ /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+ /// and \c POST_HEAP otherwise.
+ /// In the latter case it is possible that the item will get back
+ /// to the heap again.
/// \param i The item.
State state(const Item &i) const {
int s = _iim[i];
@@ -405,11 +410,11 @@
return State(s);
}
- /// \brief Sets the state of the \c item in the heap.
+ /// \brief Set the state of an 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.
+ /// 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) {
diff -r e746fb14e680 -r 432c54cec63c lemon/smart_graph.h
--- a/lemon/smart_graph.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/smart_graph.h Thu Nov 05 08:39:49 2009 +0100
@@ -32,10 +32,7 @@
namespace lemon {
class SmartDigraph;
- ///Base of SmartDigraph
- ///Base of SmartDigraph
- ///
class SmartDigraphBase {
protected:
@@ -187,28 +184,26 @@
///
///\brief A smart directed graph class.
///
- ///This is a simple and fast digraph implementation.
- ///It is also quite memory efficient, but at the price
- ///that <b> it does support only limited (only stack-like)
- ///node and arc deletions</b>.
- ///It fully conforms to the \ref concepts::Digraph "Digraph concept".
+ ///\ref SmartDigraph is a simple and fast digraph implementation.
+ ///It is also quite memory efficient but at the price
+ ///that it does not support node and arc deletion
+ ///(except for the Snapshot feature).
///
- ///\sa concepts::Digraph.
+ ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
+ ///and it also provides some additional functionalities.
+ ///Most of its member functions and nested classes are documented
+ ///only in the concept class.
+ ///
+ ///\sa concepts::Digraph
+ ///\sa SmartGraph
class SmartDigraph : public ExtendedSmartDigraphBase {
typedef ExtendedSmartDigraphBase Parent;
private:
-
- ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
-
- ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
- ///
+ /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {};
- ///\brief Assignment of SmartDigraph to another one is \e not allowed.
- ///Use DigraphCopy() instead.
-
- ///Assignment of SmartDigraph to another one is \e not allowed.
- ///Use DigraphCopy() instead.
+ /// \brief Assignment of a digraph to another one is \e not allowed.
+ /// Use DigraphCopy instead.
void operator=(const SmartDigraph &) {}
public:
@@ -221,79 +216,49 @@
///Add a new node to the digraph.
- /// Add a new node to the digraph.
- /// \return The new node.
+ ///This function adds a new node to the digraph.
+ ///\return The new node.
Node addNode() { return Parent::addNode(); }
///Add a new arc to the digraph.
- ///Add a new arc to the digraph with source node \c s
+ ///This function adds a new arc to the digraph with source node \c s
///and target node \c t.
///\return The new arc.
- Arc addArc(const Node& s, const Node& t) {
+ Arc addArc(Node s, Node t) {
return Parent::addArc(s, t);
}
- /// \brief Using this it is possible to avoid the superfluous memory
- /// allocation.
-
- /// Using this it is possible to avoid the superfluous memory
- /// allocation: if you know that the digraph you want to build will
- /// be very large (e.g. it will contain millions of nodes and/or arcs)
- /// then it is worth reserving space for this amount before starting
- /// to build the digraph.
- /// \sa reserveArc
- void reserveNode(int n) { nodes.reserve(n); };
-
- /// \brief Using this it is possible to avoid the superfluous memory
- /// allocation.
-
- /// Using this it is possible to avoid the superfluous memory
- /// allocation: if you know that the digraph you want to build will
- /// be very large (e.g. it will contain millions of nodes and/or arcs)
- /// then it is worth reserving space for this amount before starting
- /// to build the digraph.
- /// \sa reserveNode
- void reserveArc(int m) { arcs.reserve(m); };
-
/// \brief Node validity check
///
- /// This function gives back true if the given node is valid,
- /// ie. it is a real node of the graph.
+ /// This function gives back \c true if the given node is valid,
+ /// i.e. it is a real node of the digraph.
///
/// \warning A removed node (using Snapshot) could become valid again
- /// when new nodes are added to the graph.
+ /// if new nodes are added to the digraph.
bool valid(Node n) const { return Parent::valid(n); }
/// \brief Arc validity check
///
- /// This function gives back true if the given arc is valid,
- /// ie. it is a real arc of the graph.
+ /// This function gives back \c true if the given arc is valid,
+ /// i.e. it is a real arc of the digraph.
///
/// \warning A removed arc (using Snapshot) could become valid again
- /// when new arcs are added to the graph.
+ /// if new arcs are added to the graph.
bool valid(Arc a) const { return Parent::valid(a); }
- ///Clear the digraph.
-
- ///Erase all the nodes and arcs from the digraph.
- ///
- void clear() {
- Parent::clear();
- }
-
///Split a node.
- ///This function splits a node. First a new node is added to the digraph,
- ///then the source of each outgoing arc of \c n is moved to this new node.
- ///If \c connect is \c true (this is the default value), then a new arc
- ///from \c n to the newly created node is also added.
+ ///This function splits the given node. First, a new node is added
+ ///to the digraph, then the source of each outgoing arc of node \c n
+ ///is moved to this new node.
+ ///If the second parameter \c connect is \c true (this is the default
+ ///value), then a new arc from node \c n to the newly created node
+ ///is also added.
///\return The newly created node.
///
- ///\note The <tt>Arc</tt>s
- ///referencing a moved arc remain
- ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
- ///may be invalidated.
+ ///\note All iterators remain valid.
+ ///
///\warning This functionality cannot be used together with the Snapshot
///feature.
Node split(Node n, bool connect = true)
@@ -308,6 +273,34 @@
return b;
}
+ ///Clear the digraph.
+
+ ///This function erases all nodes and arcs from the digraph.
+ ///
+ void clear() {
+ Parent::clear();
+ }
+
+ /// Reserve memory for nodes.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the digraph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or arcs),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the digraph.
+ /// \sa reserveArc()
+ void reserveNode(int n) { nodes.reserve(n); };
+
+ /// Reserve memory for arcs.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the digraph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or arcs),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the digraph.
+ /// \sa reserveNode()
+ void reserveArc(int m) { arcs.reserve(m); };
+
public:
class Snapshot;
@@ -332,20 +325,23 @@
public:
- ///Class to make a snapshot of the digraph and to restrore to it later.
+ ///Class to make a snapshot of the digraph and to restore it later.
- ///Class to make a snapshot of the digraph and to restrore to it later.
+ ///Class to make a snapshot of the digraph and to restore it later.
///
///The newly added nodes and arcs can be removed using the
- ///restore() function.
- ///\note After you restore a state, you cannot restore
- ///a later state, in other word you cannot add again the arcs deleted
- ///by restore() using another one Snapshot instance.
+ ///restore() function. This is the only way for deleting nodes and/or
+ ///arcs from a SmartDigraph structure.
///
- ///\warning If you do not use correctly the snapshot that can cause
- ///either broken program, invalid state of the digraph, valid but
- ///not the restored digraph or no change. Because the runtime performance
- ///the validity of the snapshot is not stored.
+ ///\note After a state is restored, you cannot restore a later state,
+ ///i.e. you cannot add the removed nodes and arcs again using
+ ///another Snapshot instance.
+ ///
+ ///\warning Node splitting cannot be restored.
+ ///\warning The validity of the snapshot is not stored due to
+ ///performance reasons. If you do not use the snapshot correctly,
+ ///it can cause broken program, invalid or not restored state of
+ ///the digraph or no change.
class Snapshot
{
SmartDigraph *_graph;
@@ -357,39 +353,32 @@
///Default constructor.
///Default constructor.
- ///To actually make a snapshot you must call save().
- ///
+ ///You have to call save() to actually make a snapshot.
Snapshot() : _graph(0) {}
///Constructor that immediately makes a snapshot
- ///This constructor immediately makes a snapshot of the digraph.
- ///\param graph The digraph we make a snapshot of.
- Snapshot(SmartDigraph &graph) : _graph(&graph) {
+ ///This constructor immediately makes a snapshot of the given digraph.
+ ///
+ Snapshot(SmartDigraph &gr) : _graph(&gr) {
node_num=_graph->nodes.size();
arc_num=_graph->arcs.size();
}
///Make a snapshot.
- ///Make a snapshot of the digraph.
- ///
- ///This function can be called more than once. In case of a repeated
+ ///This function makes a snapshot of the given digraph.
+ ///It can be called more than once. In case of a repeated
///call, the previous snapshot gets lost.
- ///\param graph The digraph we make the snapshot of.
- void save(SmartDigraph &graph)
- {
- _graph=&graph;
+ void save(SmartDigraph &gr) {
+ _graph=&gr;
node_num=_graph->nodes.size();
arc_num=_graph->arcs.size();
}
///Undo the changes until a snapshot.
- ///Undo the changes until a snapshot created by save().
- ///
- ///\note After you restored a state, you cannot restore
- ///a later state, in other word you cannot add again the arcs deleted
- ///by restore().
+ ///This function undos the changes until the last snapshot
+ ///created by save() or Snapshot(SmartDigraph&).
void restore()
{
_graph->restoreSnapshot(*this);
@@ -621,29 +610,26 @@
///
/// \brief A smart undirected graph class.
///
- /// This is a simple and fast graph implementation.
- /// It is also quite memory efficient, but at the price
- /// that <b> it does support only limited (only stack-like)
- /// node and arc deletions</b>.
- /// It fully conforms to the \ref concepts::Graph "Graph concept".
+ /// \ref SmartGraph is a simple and fast graph implementation.
+ /// It is also quite memory efficient but at the price
+ /// that it does not support node and edge deletion
+ /// (except for the Snapshot feature).
///
- /// \sa concepts::Graph.
+ /// This type fully conforms to the \ref concepts::Graph "Graph concept"
+ /// and it also provides some additional functionalities.
+ /// Most of its member functions and nested classes are documented
+ /// only in the concept class.
+ ///
+ /// \sa concepts::Graph
+ /// \sa SmartDigraph
class SmartGraph : public ExtendedSmartGraphBase {
typedef ExtendedSmartGraphBase Parent;
private:
-
- ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
-
- ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
- ///
+ /// Graphs are \e not copy constructible. Use GraphCopy instead.
SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};
-
- ///\brief Assignment of SmartGraph to another one is \e not allowed.
- ///Use GraphCopy() instead.
-
- ///Assignment of SmartGraph to another one is \e not allowed.
- ///Use GraphCopy() instead.
+ /// \brief Assignment of a graph to another one is \e not allowed.
+ /// Use GraphCopy instead.
void operator=(const SmartGraph &) {}
public:
@@ -654,56 +640,77 @@
///
SmartGraph() {}
- ///Add a new node to the graph.
-
- /// Add a new node to the graph.
+ /// \brief Add a new node to the graph.
+ ///
+ /// This function adds a new node to the graph.
/// \return The new node.
Node addNode() { return Parent::addNode(); }
- ///Add a new edge to the graph.
-
- ///Add a new edge to the graph with node \c s
- ///and \c t.
- ///\return The new edge.
- Edge addEdge(const Node& s, const Node& t) {
- return Parent::addEdge(s, t);
+ /// \brief Add a new edge to the graph.
+ ///
+ /// This function adds a new edge to the graph between nodes
+ /// \c u and \c v with inherent orientation from node \c u to
+ /// node \c v.
+ /// \return The new edge.
+ Edge addEdge(Node u, Node v) {
+ return Parent::addEdge(u, v);
}
/// \brief Node validity check
///
- /// This function gives back true if the given node is valid,
- /// ie. it is a real node of the graph.
+ /// This function gives back \c true if the given node is valid,
+ /// i.e. it is a real node of the graph.
///
/// \warning A removed node (using Snapshot) could become valid again
- /// when new nodes are added to the graph.
+ /// if new nodes are added to the graph.
bool valid(Node n) const { return Parent::valid(n); }
+ /// \brief Edge validity check
+ ///
+ /// This function gives back \c true if the given edge is valid,
+ /// i.e. it is a real edge of the graph.
+ ///
+ /// \warning A removed edge (using Snapshot) could become valid again
+ /// if new edges are added to the graph.
+ bool valid(Edge e) const { return Parent::valid(e); }
+
/// \brief Arc validity check
///
- /// This function gives back true if the given arc is valid,
- /// ie. it is a real arc of the graph.
+ /// This function gives back \c true if the given arc is valid,
+ /// i.e. it is a real arc of the graph.
///
/// \warning A removed arc (using Snapshot) could become valid again
- /// when new edges are added to the graph.
+ /// if new edges are added to the graph.
bool valid(Arc a) const { return Parent::valid(a); }
- /// \brief Edge validity check
- ///
- /// This function gives back true if the given edge is valid,
- /// ie. it is a real edge of the graph.
- ///
- /// \warning A removed edge (using Snapshot) could become valid again
- /// when new edges are added to the graph.
- bool valid(Edge e) const { return Parent::valid(e); }
-
///Clear the graph.
- ///Erase all the nodes and edges from the graph.
+ ///This function erases all nodes and arcs from the graph.
///
void clear() {
Parent::clear();
}
+ /// Reserve memory for nodes.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the graph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or edges),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the graph.
+ /// \sa reserveEdge()
+ void reserveNode(int n) { nodes.reserve(n); };
+
+ /// Reserve memory for edges.
+
+ /// Using this function, it is possible to avoid superfluous memory
+ /// allocation: if you know that the graph you want to build will
+ /// be large (e.g. it will contain millions of nodes and/or edges),
+ /// then it is worth reserving space for this amount before starting
+ /// to build the graph.
+ /// \sa reserveNode()
+ void reserveEdge(int m) { arcs.reserve(2 * m); };
+
public:
class Snapshot;
@@ -742,21 +749,22 @@
public:
- ///Class to make a snapshot of the digraph and to restrore to it later.
+ ///Class to make a snapshot of the graph and to restore it later.
- ///Class to make a snapshot of the digraph and to restrore to it later.
+ ///Class to make a snapshot of the graph and to restore it later.
///
- ///The newly added nodes and arcs can be removed using the
- ///restore() function.
+ ///The newly added nodes and edges can be removed using the
+ ///restore() function. This is the only way for deleting nodes and/or
+ ///edges from a SmartGraph structure.
///
- ///\note After you restore a state, you cannot restore
- ///a later state, in other word you cannot add again the arcs deleted
- ///by restore() using another one Snapshot instance.
+ ///\note After a state is restored, you cannot restore a later state,
+ ///i.e. you cannot add the removed nodes and edges again using
+ ///another Snapshot instance.
///
- ///\warning If you do not use correctly the snapshot that can cause
- ///either broken program, invalid state of the digraph, valid but
- ///not the restored digraph or no change. Because the runtime performance
- ///the validity of the snapshot is not stored.
+ ///\warning The validity of the snapshot is not stored due to
+ ///performance reasons. If you do not use the snapshot correctly,
+ ///it can cause broken program, invalid or not restored state of
+ ///the graph or no change.
class Snapshot
{
SmartGraph *_graph;
@@ -768,36 +776,30 @@
///Default constructor.
///Default constructor.
- ///To actually make a snapshot you must call save().
- ///
+ ///You have to call save() to actually make a snapshot.
Snapshot() : _graph(0) {}
///Constructor that immediately makes a snapshot
- ///This constructor immediately makes a snapshot of the digraph.
- ///\param graph The digraph we make a snapshot of.
- Snapshot(SmartGraph &graph) {
- graph.saveSnapshot(*this);
+ /// This constructor immediately makes a snapshot of the given graph.
+ ///
+ Snapshot(SmartGraph &gr) {
+ gr.saveSnapshot(*this);
}
///Make a snapshot.
- ///Make a snapshot of the graph.
- ///
- ///This function can be called more than once. In case of a repeated
+ ///This function makes a snapshot of the given graph.
+ ///It can be called more than once. In case of a repeated
///call, the previous snapshot gets lost.
- ///\param graph The digraph we make the snapshot of.
- void save(SmartGraph &graph)
+ void save(SmartGraph &gr)
{
- graph.saveSnapshot(*this);
+ gr.saveSnapshot(*this);
}
- ///Undo the changes until a snapshot.
+ ///Undo the changes until the last snapshot.
- ///Undo the changes until a snapshot created by save().
- ///
- ///\note After you restored a state, you cannot restore
- ///a later state, in other word you cannot add again the arcs deleted
- ///by restore().
+ ///This function undos the changes until the last snapshot
+ ///created by save() or Snapshot(SmartGraph&).
void restore()
{
_graph->restoreSnapshot(*this);
diff -r e746fb14e680 -r 432c54cec63c lemon/soplex.cc
--- a/lemon/soplex.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/soplex.cc Thu Nov 05 08:39:49 2009 +0100
@@ -91,6 +91,19 @@
return soplex->nRows() - 1;
}
+ int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
+ soplex::DSVector v;
+ for (ExprIterator it = b; it != e; ++it) {
+ v.add(it->first, it->second);
+ }
+ soplex::LPRow r(l, v, u);
+ soplex->addRow(r);
+
+ _row_names.push_back(std::string());
+
+ return soplex->nRows() - 1;
+ }
+
void SoplexLp::_eraseCol(int i) {
soplex->removeCol(i);
diff -r e746fb14e680 -r 432c54cec63c lemon/soplex.h
--- a/lemon/soplex.h Tue Aug 18 10:08:28 2009 +0200
+++ b/lemon/soplex.h Thu Nov 05 08:39:49 2009 +0100
@@ -84,6 +84,7 @@
virtual int _addCol();
virtual int _addRow();
+ virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
virtual void _eraseCol(int i);
virtual void _eraseRow(int i);
diff -r e746fb14e680 -r 432c54cec63c m4/lx_check_coin.m4
--- a/m4/lx_check_coin.m4 Tue Aug 18 10:08:28 2009 +0200
+++ b/m4/lx_check_coin.m4 Thu Nov 05 08:39:49 2009 +0100
@@ -88,7 +88,7 @@
elif test x"$with_coin" != x"yes"; then
CBC_LDFLAGS="-L$with_coin/lib"
fi
- CBC_LIBS="-lOsi -lCbc -lOsiCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
+ CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
lx_save_cxxflags="$CXXFLAGS"
lx_save_ldflags="$LDFLAGS"
diff -r e746fb14e680 -r 432c54cec63c scripts/bib2dox.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/scripts/bib2dox.py Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,811 @@
+#!/usr/bin/env /usr/local/Python/bin/python2.1
+"""
+ BibTeX to Doxygen converter
+ Usage: python bib2dox.py bibfile.bib > bibfile.dox
+
+ This code is the modification of the BibTeX to XML converter
+ by Vidar Bronken Gundersen et al. See the original copyright notices below.
+
+ **********************************************************************
+
+ Decoder for bibliographic data, BibTeX
+ Usage: python bibtex2xml.py bibfile.bib > bibfile.xml
+
+ v.8
+ (c)2002-06-23 Vidar Bronken Gundersen
+ http://bibtexml.sf.net/
+ Reuse approved as long as this notification is kept.
+ Licence: GPL.
+
+ Contributions/thanks to:
+ Egon Willighagen, http://sf.net/projects/jreferences/
+ Richard Mahoney (for providing a test case)
+
+ Editted by Sara Sprenkle to be more robust and handle more bibtex features.
+ (c) 2003-01-15
+
+ 1. Changed bibtex: tags to bibxml: tags.
+ 2. Use xmlns:bibxml="http://bibtexml.sf.net/"
+ 3. Allow spaces between @type and first {
+ 4. "author" fields with multiple authors split by " and "
+ are put in separate xml "bibxml:author" tags.
+ 5. Option for Titles: words are capitalized
+ only if first letter in title or capitalized inside braces
+ 6. Removes braces from within field values
+ 7. Ignores comments in bibtex file (including @comment{ or % )
+ 8. Replaces some special latex tags, e.g., replaces ~ with ' '
+ 9. Handles bibtex @string abbreviations
+ --> includes bibtex's default abbreviations for months
+ --> does concatenation of abbr # " more " and " more " # abbr
+ 10. Handles @type( ... ) or @type{ ... }
+ 11. The keywords field is split on , or ; and put into separate xml
+ "bibxml:keywords" tags
+ 12. Ignores @preamble
+
+ Known Limitations
+ 1. Does not transform Latex encoding like math mode and special
+ latex symbols.
+ 2. Does not parse author fields into first and last names.
+ E.g., It does not do anything special to an author whose name is
+ in the form LAST_NAME, FIRST_NAME
+ In "author" tag, will show up as
+ <bibxml:author>LAST_NAME, FIRST_NAME</bibxml:author>
+ 3. Does not handle "crossref" fields other than to print
+ <bibxml:crossref>...</bibxml:crossref>
+ 4. Does not inform user of the input's format errors. You just won't
+ be able to transform the file later with XSL
+
+ You will have to manually edit the XML output if you need to handle
+ these (and unknown) limitations.
+
+"""
+
+import string, re
+
+# set of valid name characters
+valid_name_chars = '[\w\-:]'
+
+#
+# define global regular expression variables
+#
+author_rex = re.compile('\s+and\s+')
+rembraces_rex = re.compile('[{}]')
+capitalize_rex = re.compile('({[^}]*})')
+
+# used by bibtexkeywords(data)
+keywords_rex = re.compile('[,;]')
+
+# used by concat_line(line)
+concatsplit_rex = re.compile('\s*#\s*')
+
+# split on {, }, or " in verify_out_of_braces
+delimiter_rex = re.compile('([{}"])',re.I)
+
+field_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
+data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?')
+
+url_rex = re.compile('\\\url\{([^}]*)\}')
+
+#
+# styles for html formatting
+#
+divstyle = 'margin-top: -4ex; margin-left: 8em;'
+
+#
+# return the string parameter without braces
+#
+def transformurls(str):
+ return url_rex.sub(r'<a href="\1">\1</a>', str)
+
+#
+# return the string parameter without braces
+#
+def removebraces(str):
+ return rembraces_rex.sub('', str)
+
+#
+# latex-specific replacements
+# (do this after braces were removed)
+#
+def latexreplacements(line):
+ line = string.replace(line, '~', ' ')
+ line = string.replace(line, '\\\'a', 'á')
+ line = string.replace(line, '\\"a', 'ä')
+ line = string.replace(line, '\\\'e', 'é')
+ line = string.replace(line, '\\"e', 'ë')
+ line = string.replace(line, '\\\'i', 'í')
+ line = string.replace(line, '\\"i', 'ï')
+ line = string.replace(line, '\\\'o', 'ó')
+ line = string.replace(line, '\\"o', 'ö')
+ line = string.replace(line, '\\\'u', 'ú')
+ line = string.replace(line, '\\"u', 'ü')
+ line = string.replace(line, '\\H o', 'õ')
+ line = string.replace(line, '\\H u', 'ü') # ũ does not exist
+ line = string.replace(line, '\\\'A', 'Á')
+ line = string.replace(line, '\\"A', 'Ä')
+ line = string.replace(line, '\\\'E', 'É')
+ line = string.replace(line, '\\"E', 'Ë')
+ line = string.replace(line, '\\\'I', 'Í')
+ line = string.replace(line, '\\"I', 'Ï')
+ line = string.replace(line, '\\\'O', 'Ó')
+ line = string.replace(line, '\\"O', 'Ö')
+ line = string.replace(line, '\\\'U', 'Ú')
+ line = string.replace(line, '\\"U', 'Ü')
+ line = string.replace(line, '\\H O', 'Õ')
+ line = string.replace(line, '\\H U', 'Ü') # Ũ does not exist
+
+ return line
+
+#
+# copy characters form a string decoding html expressions (&xyz;)
+#
+def copychars(str, ifrom, count):
+ result = ''
+ i = ifrom
+ c = 0
+ html_spec = False
+ while (i < len(str)) and (c < count):
+ if str[i] == '&':
+ html_spec = True;
+ if i+1 < len(str):
+ result += str[i+1]
+ c += 1
+ i += 2
+ else:
+ if not html_spec:
+ if ((str[i] >= 'A') and (str[i] <= 'Z')) or \
+ ((str[i] >= 'a') and (str[i] <= 'z')):
+ result += str[i]
+ c += 1
+ elif str[i] == ';':
+ html_spec = False;
+ i += 1
+
+ return result
+
+
+#
+# Handle a list of authors (separated by 'and').
+# It gives back an array of the follwing values:
+# - num: the number of authors,
+# - list: the list of the author names,
+# - text: the bibtex text (separated by commas and/or 'and')
+# - abbrev: abbreviation that can be used for indicate the
+# bibliography entries
+#
+def bibtexauthor(data):
+ result = {}
+ bibtex = ''
+ result['list'] = author_rex.split(data)
+ result['num'] = len(result['list'])
+ for i, author in enumerate(result['list']):
+ # general transformations
+ author = latexreplacements(removebraces(author.strip()))
+ # transform "Xyz, A. B." to "A. B. Xyz"
+ pos = author.find(',')
+ if pos != -1:
+ author = author[pos+1:].strip() + ' ' + author[:pos].strip()
+ result['list'][i] = author
+ bibtex += author + '#'
+ bibtex = bibtex[:-1]
+ if result['num'] > 1:
+ ix = bibtex.rfind('#')
+ if result['num'] == 2:
+ bibtex = bibtex[:ix] + ' and ' + bibtex[ix+1:]
+ else:
+ bibtex = bibtex[:ix] + ', and ' + bibtex[ix+1:]
+ bibtex = bibtex.replace('#', ', ')
+ result['text'] = bibtex
+
+ result['abbrev'] = ''
+ for author in result['list']:
+ pos = author.rfind(' ') + 1
+ count = 1
+ if result['num'] == 1:
+ count = 3
+ result['abbrev'] += copychars(author, pos, count)
+
+ return result
+
+
+#
+# data = title string
+# @return the capitalized title (first letter is capitalized), rest are capitalized
+# only if capitalized inside braces
+#
+def capitalizetitle(data):
+ title_list = capitalize_rex.split(data)
+ title = ''
+ count = 0
+ for phrase in title_list:
+ check = string.lstrip(phrase)
+
+ # keep phrase's capitalization the same
+ if check.find('{') == 0:
+ title += removebraces(phrase)
+ else:
+ # first word --> capitalize first letter (after spaces)
+ if count == 0:
+ title += check.capitalize()
+ else:
+ title += phrase.lower()
+ count = count + 1
+
+ return title
+
+
+#
+# @return the bibtex for the title
+# @param data --> title string
+# braces are removed from title
+#
+def bibtextitle(data, entrytype):
+ if entrytype in ('book', 'inbook'):
+ title = removebraces(data.strip())
+ else:
+ title = removebraces(capitalizetitle(data.strip()))
+ bibtex = title
+ return bibtex
+
+
+#
+# function to compare entry lists
+#
+def entry_cmp(x, y):
+ return cmp(x[0], y[0])
+
+
+#
+# print the XML for the transformed "filecont_source"
+#
+def bibtexdecoder(filecont_source):
+ filecont = []
+ file = []
+
+ # want @<alphanumeric chars><spaces>{<spaces><any chars>,
+ pubtype_rex = re.compile('@(\w*)\s*{\s*(.*),')
+ endtype_rex = re.compile('}\s*$')
+ endtag_rex = re.compile('^\s*}\s*$')
+
+ bracefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
+ bracedata_rex = re.compile('\s*(\w*)\s*=\s*{(.*)},?')
+
+ quotefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
+ quotedata_rex = re.compile('\s*(\w*)\s*=\s*"(.*)",?')
+
+ for line in filecont_source:
+ line = line[:-1]
+
+ # encode character entities
+ line = string.replace(line, '&', '&')
+ line = string.replace(line, '<', '<')
+ line = string.replace(line, '>', '>')
+
+ # start entry: publication type (store for later use)
+ if pubtype_rex.match(line):
+ # want @<alphanumeric chars><spaces>{<spaces><any chars>,
+ entrycont = {}
+ entry = []
+ entrytype = pubtype_rex.sub('\g<1>',line)
+ entrytype = string.lower(entrytype)
+ entryid = pubtype_rex.sub('\g<2>', line)
+
+ # end entry if just a }
+ elif endtype_rex.match(line):
+ # generate doxygen code for the entry
+
+ # enty type related formattings
+ if entrytype in ('book', 'inbook'):
+ entrycont['title'] = '<em>' + entrycont['title'] + '</em>'
+ if not entrycont.has_key('author'):
+ entrycont['author'] = entrycont['editor']
+ entrycont['author']['text'] += ', editors'
+ elif entrytype == 'article':
+ entrycont['journal'] = '<em>' + entrycont['journal'] + '</em>'
+ elif entrytype in ('inproceedings', 'incollection', 'conference'):
+ entrycont['booktitle'] = '<em>' + entrycont['booktitle'] + '</em>'
+ elif entrytype == 'techreport':
+ if not entrycont.has_key('type'):
+ entrycont['type'] = 'Technical report'
+ elif entrytype == 'mastersthesis':
+ entrycont['type'] = 'Master\'s thesis'
+ elif entrytype == 'phdthesis':
+ entrycont['type'] = 'PhD thesis'
+
+ for eline in entrycont:
+ if eline != '':
+ eline = latexreplacements(eline)
+
+ if entrycont.has_key('pages') and (entrycont['pages'] != ''):
+ entrycont['pages'] = string.replace(entrycont['pages'], '--', '-')
+
+ if entrycont.has_key('author') and (entrycont['author'] != ''):
+ entry.append(entrycont['author']['text'] + '.')
+ if entrycont.has_key('title') and (entrycont['title'] != ''):
+ entry.append(entrycont['title'] + '.')
+ if entrycont.has_key('journal') and (entrycont['journal'] != ''):
+ entry.append(entrycont['journal'] + ',')
+ if entrycont.has_key('booktitle') and (entrycont['booktitle'] != ''):
+ entry.append('In ' + entrycont['booktitle'] + ',')
+ if entrycont.has_key('type') and (entrycont['type'] != ''):
+ eline = entrycont['type']
+ if entrycont.has_key('number') and (entrycont['number'] != ''):
+ eline += ' ' + entrycont['number']
+ eline += ','
+ entry.append(eline)
+ if entrycont.has_key('institution') and (entrycont['institution'] != ''):
+ entry.append(entrycont['institution'] + ',')
+ if entrycont.has_key('publisher') and (entrycont['publisher'] != ''):
+ entry.append(entrycont['publisher'] + ',')
+ if entrycont.has_key('school') and (entrycont['school'] != ''):
+ entry.append(entrycont['school'] + ',')
+ if entrycont.has_key('address') and (entrycont['address'] != ''):
+ entry.append(entrycont['address'] + ',')
+ if entrycont.has_key('edition') and (entrycont['edition'] != ''):
+ entry.append(entrycont['edition'] + ' edition,')
+ if entrycont.has_key('howpublished') and (entrycont['howpublished'] != ''):
+ entry.append(entrycont['howpublished'] + ',')
+ if entrycont.has_key('volume') and (entrycont['volume'] != ''):
+ eline = entrycont['volume'];
+ if entrycont.has_key('number') and (entrycont['number'] != ''):
+ eline += '(' + entrycont['number'] + ')'
+ if entrycont.has_key('pages') and (entrycont['pages'] != ''):
+ eline += ':' + entrycont['pages']
+ eline += ','
+ entry.append(eline)
+ else:
+ if entrycont.has_key('pages') and (entrycont['pages'] != ''):
+ entry.append('pages ' + entrycont['pages'] + ',')
+ if entrycont.has_key('year') and (entrycont['year'] != ''):
+ if entrycont.has_key('month') and (entrycont['month'] != ''):
+ entry.append(entrycont['month'] + ' ' + entrycont['year'] + '.')
+ else:
+ entry.append(entrycont['year'] + '.')
+ if entrycont.has_key('note') and (entrycont['note'] != ''):
+ entry.append(entrycont['note'] + '.')
+ if entrycont.has_key('url') and (entrycont['url'] != ''):
+ entry.append(entrycont['url'] + '.')
+
+ # generate keys for sorting and for the output
+ sortkey = ''
+ bibkey = ''
+ if entrycont.has_key('author'):
+ for author in entrycont['author']['list']:
+ sortkey += copychars(author, author.rfind(' ')+1, len(author))
+ bibkey = entrycont['author']['abbrev']
+ else:
+ bibkey = 'x'
+ if entrycont.has_key('year'):
+ sortkey += entrycont['year']
+ bibkey += entrycont['year'][-2:]
+ if entrycont.has_key('title'):
+ sortkey += entrycont['title']
+ if entrycont.has_key('key'):
+ sortkey = entrycont['key'] + sortkey
+ bibkey = entrycont['key']
+ entry.insert(0, sortkey)
+ entry.insert(1, bibkey)
+ entry.insert(2, entryid)
+
+ # add the entry to the file contents
+ filecont.append(entry)
+
+ else:
+ # field, publication info
+ field = ''
+ data = ''
+
+ # field = {data} entries
+ if bracedata_rex.match(line):
+ field = bracefield_rex.sub('\g<1>', line)
+ field = string.lower(field)
+ data = bracedata_rex.sub('\g<2>', line)
+
+ # field = "data" entries
+ elif quotedata_rex.match(line):
+ field = quotefield_rex.sub('\g<1>', line)
+ field = string.lower(field)
+ data = quotedata_rex.sub('\g<2>', line)
+
+ # field = data entries
+ elif data_rex.match(line):
+ field = field_rex.sub('\g<1>', line)
+ field = string.lower(field)
+ data = data_rex.sub('\g<2>', line)
+
+ if field == 'url':
+ data = '\\url{' + data.strip() + '}'
+
+ if field in ('author', 'editor'):
+ entrycont[field] = bibtexauthor(data)
+ line = ''
+ elif field == 'title':
+ line = bibtextitle(data, entrytype)
+ elif field != '':
+ line = removebraces(transformurls(data.strip()))
+
+ if line != '':
+ line = latexreplacements(line)
+ entrycont[field] = line
+
+
+ # sort entries
+ filecont.sort(entry_cmp)
+
+ # count the bibtex keys
+ keytable = {}
+ counttable = {}
+ for entry in filecont:
+ bibkey = entry[1]
+ if not keytable.has_key(bibkey):
+ keytable[bibkey] = 1
+ else:
+ keytable[bibkey] += 1
+
+ for bibkey in keytable.keys():
+ counttable[bibkey] = 0
+
+ # generate output
+ for entry in filecont:
+ # generate output key form the bibtex key
+ bibkey = entry[1]
+ entryid = entry[2]
+ if keytable[bibkey] == 1:
+ outkey = bibkey
+ else:
+ outkey = bibkey + chr(97 + counttable[bibkey])
+ counttable[bibkey] += 1
+
+ # append the entry code to the output
+ file.append('\\section ' + entryid + ' [' + outkey + ']')
+ file.append('<div style="' + divstyle + '">')
+ for line in entry[3:]:
+ file.append(line)
+ file.append('</div>')
+ file.append('')
+
+ return file
+
+
+#
+# return 1 iff abbr is in line but not inside braces or quotes
+# assumes that abbr appears only once on the line (out of braces and quotes)
+#
+def verify_out_of_braces(line, abbr):
+
+ phrase_split = delimiter_rex.split(line)
+
+ abbr_rex = re.compile( '\\b' + abbr + '\\b', re.I)
+
+ open_brace = 0
+ open_quote = 0
+
+ for phrase in phrase_split:
+ if phrase == "{":
+ open_brace = open_brace + 1
+ elif phrase == "}":
+ open_brace = open_brace - 1
+ elif phrase == '"':
+ if open_quote == 1:
+ open_quote = 0
+ else:
+ open_quote = 1
+ elif abbr_rex.search(phrase):
+ if open_brace == 0 and open_quote == 0:
+ return 1
+
+ return 0
+
+
+#
+# a line in the form phrase1 # phrase2 # ... # phrasen
+# is returned as phrase1 phrase2 ... phrasen
+# with the correct punctuation
+# Bug: Doesn't always work with multiple abbreviations plugged in
+#
+def concat_line(line):
+ # only look at part after equals
+ field = field_rex.sub('\g<1>',line)
+ rest = field_rex.sub('\g<2>',line)
+
+ concat_line = field + ' ='
+
+ pound_split = concatsplit_rex.split(rest)
+
+ phrase_count = 0
+ length = len(pound_split)
+
+ for phrase in pound_split:
+ phrase = phrase.strip()
+ if phrase_count != 0:
+ if phrase.startswith('"') or phrase.startswith('{'):
+ phrase = phrase[1:]
+ elif phrase.startswith('"'):
+ phrase = phrase.replace('"','{',1)
+
+ if phrase_count != length-1:
+ if phrase.endswith('"') or phrase.endswith('}'):
+ phrase = phrase[:-1]
+ else:
+ if phrase.endswith('"'):
+ phrase = phrase[:-1]
+ phrase = phrase + "}"
+ elif phrase.endswith('",'):
+ phrase = phrase[:-2]
+ phrase = phrase + "},"
+
+ # if phrase did have \#, add the \# back
+ if phrase.endswith('\\'):
+ phrase = phrase + "#"
+ concat_line = concat_line + ' ' + phrase
+
+ phrase_count = phrase_count + 1
+
+ return concat_line
+
+
+#
+# substitute abbreviations into filecont
+# @param filecont_source - string of data from file
+#
+def bibtex_replace_abbreviations(filecont_source):
+ filecont = filecont_source.splitlines()
+
+ # These are defined in bibtex, so we'll define them too
+ abbr_list = ['jan','feb','mar','apr','may','jun',
+ 'jul','aug','sep','oct','nov','dec']
+ value_list = ['January','February','March','April',
+ 'May','June','July','August','September',
+ 'October','November','December']
+
+ abbr_rex = []
+ total_abbr_count = 0
+
+ front = '\\b'
+ back = '(,?)\\b'
+
+ for x in abbr_list:
+ abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )
+ total_abbr_count = total_abbr_count + 1
+
+
+ abbrdef_rex = re.compile('\s*@string\s*{\s*('+ valid_name_chars +'*)\s*=(.*)',
+ re.I)
+
+ comment_rex = re.compile('@comment\s*{',re.I)
+ preamble_rex = re.compile('@preamble\s*{',re.I)
+
+ waiting_for_end_string = 0
+ i = 0
+ filecont2 = ''
+
+ for line in filecont:
+ if line == ' ' or line == '':
+ continue
+
+ if waiting_for_end_string:
+ if re.search('}',line):
+ waiting_for_end_string = 0
+ continue
+
+ if abbrdef_rex.search(line):
+ abbr = abbrdef_rex.sub('\g<1>', line)
+
+ if abbr_list.count(abbr) == 0:
+ val = abbrdef_rex.sub('\g<2>', line)
+ abbr_list.append(abbr)
+ value_list.append(string.strip(val))
+ abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )
+ total_abbr_count = total_abbr_count + 1
+ waiting_for_end_string = 1
+ continue
+
+ if comment_rex.search(line):
+ waiting_for_end_string = 1
+ continue
+
+ if preamble_rex.search(line):
+ waiting_for_end_string = 1
+ continue
+
+
+ # replace subsequent abbreviations with the value
+ abbr_count = 0
+
+ for x in abbr_list:
+
+ if abbr_rex[abbr_count].search(line):
+ if verify_out_of_braces(line,abbr_list[abbr_count]) == 1:
+ line = abbr_rex[abbr_count].sub( value_list[abbr_count] + '\g<1>', line)
+ # Check for # concatenations
+ if concatsplit_rex.search(line):
+ line = concat_line(line)
+ abbr_count = abbr_count + 1
+
+
+ filecont2 = filecont2 + line + '\n'
+ i = i+1
+
+
+ # Do one final pass over file
+
+ # make sure that didn't end up with {" or }" after the substitution
+ filecont2 = filecont2.replace('{"','{{')
+ filecont2 = filecont2.replace('"}','}}')
+
+ afterquotevalue_rex = re.compile('"\s*,\s*')
+ afterbrace_rex = re.compile('"\s*}')
+ afterbracevalue_rex = re.compile('(=\s*{[^=]*)},\s*')
+
+ # add new lines to data that changed because of abbreviation substitutions
+ filecont2 = afterquotevalue_rex.sub('",\n', filecont2)
+ filecont2 = afterbrace_rex.sub('"\n}', filecont2)
+ filecont2 = afterbracevalue_rex.sub('\g<1>},\n', filecont2)
+
+ return filecont2
+
+#
+# convert @type( ... ) to @type{ ... }
+#
+def no_outer_parens(filecont):
+
+ # do checking for open parens
+ # will convert to braces
+ paren_split = re.split('([(){}])',filecont)
+
+ open_paren_count = 0
+ open_type = 0
+ look_next = 0
+
+ # rebuild filecont
+ filecont = ''
+
+ at_rex = re.compile('@\w*')
+
+ for phrase in paren_split:
+ if look_next == 1:
+ if phrase == '(':
+ phrase = '{'
+ open_paren_count = open_paren_count + 1
+ else:
+ open_type = 0
+ look_next = 0
+
+ if phrase == '(':
+ open_paren_count = open_paren_count + 1
+
+ elif phrase == ')':
+ open_paren_count = open_paren_count - 1
+ if open_type == 1 and open_paren_count == 0:
+ phrase = '}'
+ open_type = 0
+
+ elif at_rex.search( phrase ):
+ open_type = 1
+ look_next = 1
+
+ filecont = filecont + phrase
+
+ return filecont
+
+
+#
+# make all whitespace into just one space
+# format the bibtex file into a usable form.
+#
+def bibtexwasher(filecont_source):
+
+ space_rex = re.compile('\s+')
+ comment_rex = re.compile('\s*%')
+
+ filecont = []
+
+ # remove trailing and excessive whitespace
+ # ignore comments
+ for line in filecont_source:
+ line = string.strip(line)
+ line = space_rex.sub(' ', line)
+ # ignore comments
+ if not comment_rex.match(line) and line != '':
+ filecont.append(' '+ line)
+
+ filecont = string.join(filecont, '')
+
+ # the file is in one long string
+
+ filecont = no_outer_parens(filecont)
+
+ #
+ # split lines according to preferred syntax scheme
+ #
+ filecont = re.sub('(=\s*{[^=]*)},', '\g<1>},\n', filecont)
+
+ # add new lines after commas that are after values
+ filecont = re.sub('"\s*,', '",\n', filecont)
+ filecont = re.sub('=\s*([\w\d]+)\s*,', '= \g<1>,\n', filecont)
+ filecont = re.sub('(@\w*)\s*({(\s*)[^,\s]*)\s*,',
+ '\n\n\g<1>\g<2>,\n', filecont)
+
+ # add new lines after }
+ filecont = re.sub('"\s*}','"\n}\n', filecont)
+ filecont = re.sub('}\s*,','},\n', filecont)
+
+
+ filecont = re.sub('@(\w*)', '\n@\g<1>', filecont)
+
+ # character encoding, reserved latex characters
+ filecont = re.sub('{\\\&}', '&', filecont)
+ filecont = re.sub('\\\&', '&', filecont)
+
+ # do checking for open braces to get format correct
+ open_brace_count = 0
+ brace_split = re.split('([{}])',filecont)
+
+ # rebuild filecont
+ filecont = ''
+
+ for phrase in brace_split:
+ if phrase == '{':
+ open_brace_count = open_brace_count + 1
+ elif phrase == '}':
+ open_brace_count = open_brace_count - 1
+ if open_brace_count == 0:
+ filecont = filecont + '\n'
+
+ filecont = filecont + phrase
+
+ filecont2 = bibtex_replace_abbreviations(filecont)
+
+ # gather
+ filecont = filecont2.splitlines()
+ i=0
+ j=0 # count the number of blank lines
+ for line in filecont:
+ # ignore blank lines
+ if line == '' or line == ' ':
+ j = j+1
+ continue
+ filecont[i] = line + '\n'
+ i = i+1
+
+ # get rid of the extra stuff at the end of the array
+ # (The extra stuff are duplicates that are in the array because
+ # blank lines were removed.)
+ length = len( filecont)
+ filecont[length-j:length] = []
+
+ return filecont
+
+
+def filehandler(filepath):
+ try:
+ fd = open(filepath, 'r')
+ filecont_source = fd.readlines()
+ fd.close()
+ except:
+ print 'Could not open file:', filepath
+ washeddata = bibtexwasher(filecont_source)
+ outdata = bibtexdecoder(washeddata)
+ print '/**'
+ print '\page references References'
+ print
+ for line in outdata:
+ print line
+ print '*/'
+
+
+# main program
+
+def main():
+ import sys
+ if sys.argv[1:]:
+ filepath = sys.argv[1]
+ else:
+ print "No input file"
+ sys.exit()
+ filehandler(filepath)
+
+if __name__ == "__main__": main()
+
+
+# end python script
diff -r e746fb14e680 -r 432c54cec63c scripts/bootstrap.sh
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/scripts/bootstrap.sh Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,134 @@
+#!/bin/bash
+#
+# 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.
+
+
+if [ ! -f ~/.lemon-bootstrap ]; then
+ echo 'Create ~/.lemon-bootstrap'.
+ cat >~/.lemon-bootstrap <<EOF
+#
+# Default settings for bootstraping the LEMON source code repository
+#
+EOF
+fi
+
+source ~/.lemon-bootstrap
+if [ -f ../../../.lemon-bootstrap ]; then source ../../../.lemon-bootstrap; fi
+if [ -f ../../.lemon-bootstrap ]; then source ../../.lemon-bootstrap; fi
+if [ -f ../.lemon-bootstrap ]; then source ../.lemon-bootstrap; fi
+if [ -f ./.lemon-bootstrap ]; then source ./.lemon-bootstrap; fi
+
+
+function augment_config() {
+ if [ "x${!1}" == "x" ]; then
+ eval $1=$2
+ echo Add "'$1'" to '~/.lemon-bootstrap'.
+ echo >>~/.lemon-bootstrap
+ echo $3 >>~/.lemon-bootstrap
+ echo $1=$2 >>~/.lemon-bootstrap
+ fi
+}
+
+augment_config LEMON_INSTALL_PREFIX /usr/local \
+ "# LEMON installation prefix"
+
+augment_config COIN_OR_PREFIX /usr/local/coin-or \
+ "# COIN-OR installation root prefix (used for CLP/CBC)"
+
+augment_config SOPLEX_PREFIX /usr/local/soplex \
+ "# Soplex build prefix"
+
+
+function ask() {
+echo -n "$1 [$2]? "
+read _an
+if [ "x$_an" == "x" ]; then
+ ret="$2"
+else
+ ret=$_an
+fi
+}
+
+function yesorno() {
+ ret='rossz'
+ while [ "$ret" != "y" -a "$ret" != "n" -a "$ret" != "yes" -a "$ret" != "no" ]; do
+ ask "$1" "$2"
+ done
+ if [ "$ret" != "y" -a "$ret" != "yes" ]; then
+ return 1
+ else
+ return 0
+ fi
+}
+
+if yesorno "External build" "n"
+then
+ CONFIGURE_PATH=".."
+else
+ CONFIGURE_PATH="."
+ if yesorno "Autoreconf" "y"
+ then
+ AUTORE=yes
+ else
+ AUTORE=no
+ fi
+fi
+
+if yesorno "Optimize" "n"
+then
+ opt_flags=' -O2'
+else
+ opt_flags=''
+fi
+
+if yesorno "Stop on warning" "y"
+then
+ werror_flags=' -Werror'
+else
+ werror_flags=''
+fi
+
+cxx_flags="CXXFLAGS=-ggdb$opt_flags$werror_flags"
+
+if [ -f ${COIN_OR_PREFIX}/include/coin/config_coinutils.h ]; then
+ if yesorno "Use COIN-OR (CBC/CLP)" "n"
+ then
+ coin_flag="--with-coin=$COIN_OR_PREFIX"
+ else
+ coin_flag=""
+ fi
+else
+ coin_flag=""
+fi
+
+if [ -f ${SOPLEX_PREFIX}/src/soplex.h ]; then
+ if yesorno "Use Soplex" "n"
+ then
+ soplex_flag="--with-soplex=$SOPLEX_PREFIX"
+ else
+ soplex_flag=""
+ fi
+else
+ soplex_flag=""
+fi
+
+if [ "x$AUTORE" == "xyes" ]; then
+ autoreconf -vif;
+fi
+${CONFIGURE_PATH}/configure --prefix=$LEMON_INSTALL_PREFIX \
+"$cxx_flags" \
+$coin_flag \
+$soplex_flag \
+$*
diff -r e746fb14e680 -r 432c54cec63c scripts/chg-len.py
--- a/scripts/chg-len.py Tue Aug 18 10:08:28 2009 +0200
+++ b/scripts/chg-len.py Thu Nov 05 08:39:49 2009 +0100
@@ -1,4 +1,18 @@
#! /usr/bin/env python
+#
+# 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.
import sys
diff -r e746fb14e680 -r 432c54cec63c scripts/mk-release.sh
--- a/scripts/mk-release.sh Tue Aug 18 10:08:28 2009 +0200
+++ b/scripts/mk-release.sh Thu Nov 05 08:39:49 2009 +0100
@@ -1,4 +1,18 @@
#!/bin/bash
+#
+# 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.
set -e
diff -r e746fb14e680 -r 432c54cec63c scripts/unify-sources.sh
--- a/scripts/unify-sources.sh Tue Aug 18 10:08:28 2009 +0200
+++ b/scripts/unify-sources.sh Thu Nov 05 08:39:49 2009 +0100
@@ -1,4 +1,18 @@
#!/bin/bash
+#
+# 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.
YEAR=`date +%Y`
HGROOT=`hg root`
diff -r e746fb14e680 -r 432c54cec63c test/CMakeLists.txt
--- a/test/CMakeLists.txt Tue Aug 18 10:08:28 2009 +0200
+++ b/test/CMakeLists.txt Thu Nov 05 08:39:49 2009 +0100
@@ -9,6 +9,7 @@
SET(TESTS
adaptors_test
+ bellman_ford_test
bfs_test
circulation_test
connectivity_test
diff -r e746fb14e680 -r 432c54cec63c test/Makefile.am
--- a/test/Makefile.am Tue Aug 18 10:08:28 2009 +0200
+++ b/test/Makefile.am Thu Nov 05 08:39:49 2009 +0100
@@ -7,6 +7,7 @@
check_PROGRAMS += \
test/adaptors_test \
+ test/bellman_ford_test \
test/bfs_test \
test/circulation_test \
test/connectivity_test \
@@ -53,6 +54,7 @@
XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
test_adaptors_test_SOURCES = test/adaptors_test.cc
+test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc
test_bfs_test_SOURCES = test/bfs_test.cc
test_circulation_test_SOURCES = test/circulation_test.cc
test_counter_test_SOURCES = test/counter_test.cc
diff -r e746fb14e680 -r 432c54cec63c test/bellman_ford_test.cc
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/bellman_ford_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -0,0 +1,283 @@
+/* -*- 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.
+ *
+ */
+
+#include <lemon/concepts/digraph.h>
+#include <lemon/smart_graph.h>
+#include <lemon/list_graph.h>
+#include <lemon/lgf_reader.h>
+#include <lemon/bellman_ford.h>
+#include <lemon/path.h>
+
+#include "graph_test.h"
+#include "test_tools.h"
+
+using namespace lemon;
+
+char test_lgf[] =
+ "@nodes\n"
+ "label\n"
+ "0\n"
+ "1\n"
+ "2\n"
+ "3\n"
+ "4\n"
+ "@arcs\n"
+ " length\n"
+ "0 1 3\n"
+ "1 2 -3\n"
+ "1 2 -5\n"
+ "1 3 -2\n"
+ "0 2 -1\n"
+ "1 2 -4\n"
+ "0 3 2\n"
+ "4 2 -5\n"
+ "2 3 1\n"
+ "@attributes\n"
+ "source 0\n"
+ "target 3\n";
+
+
+void checkBellmanFordCompile()
+{
+ typedef int Value;
+ typedef concepts::Digraph Digraph;
+ typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
+ typedef BellmanFord<Digraph, LengthMap> BF;
+ typedef Digraph::Node Node;
+ typedef Digraph::Arc Arc;
+
+ Digraph gr;
+ Node s, t, n;
+ Arc e;
+ Value l;
+ int k;
+ bool b;
+ BF::DistMap d(gr);
+ BF::PredMap p(gr);
+ LengthMap length;
+ concepts::Path<Digraph> pp;
+
+ {
+ BF bf_test(gr,length);
+ const BF& const_bf_test = bf_test;
+
+ bf_test.run(s);
+ bf_test.run(s,k);
+
+ bf_test.init();
+ bf_test.addSource(s);
+ bf_test.addSource(s, 1);
+ b = bf_test.processNextRound();
+ b = bf_test.processNextWeakRound();
+
+ bf_test.start();
+ bf_test.checkedStart();
+ bf_test.limitedStart(k);
+
+ l = const_bf_test.dist(t);
+ e = const_bf_test.predArc(t);
+ s = const_bf_test.predNode(t);
+ b = const_bf_test.reached(t);
+ d = const_bf_test.distMap();
+ p = const_bf_test.predMap();
+ pp = const_bf_test.path(t);
+
+ for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
+ }
+ {
+ BF::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
+ ::SetDistMap<concepts::ReadWriteMap<Node,Value> >
+ ::SetOperationTraits<BellmanFordDefaultOperationTraits<Value> >
+ ::Create bf_test(gr,length);
+
+ LengthMap length_map;
+ concepts::ReadWriteMap<Node,Arc> pred_map;
+ concepts::ReadWriteMap<Node,Value> dist_map;
+
+ bf_test
+ .lengthMap(length_map)
+ .predMap(pred_map)
+ .distMap(dist_map);
+
+ bf_test.run(s);
+ bf_test.run(s,k);
+
+ bf_test.init();
+ bf_test.addSource(s);
+ bf_test.addSource(s, 1);
+ b = bf_test.processNextRound();
+ b = bf_test.processNextWeakRound();
+
+ bf_test.start();
+ bf_test.checkedStart();
+ bf_test.limitedStart(k);
+
+ l = bf_test.dist(t);
+ e = bf_test.predArc(t);
+ s = bf_test.predNode(t);
+ b = bf_test.reached(t);
+ pp = bf_test.path(t);
+ }
+}
+
+void checkBellmanFordFunctionCompile()
+{
+ typedef int Value;
+ typedef concepts::Digraph Digraph;
+ typedef Digraph::Arc Arc;
+ typedef Digraph::Node Node;
+ typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
+
+ Digraph g;
+ bool b;
+ bellmanFord(g,LengthMap()).run(Node());
+ b = bellmanFord(g,LengthMap()).run(Node(),Node());
+ bellmanFord(g,LengthMap())
+ .predMap(concepts::ReadWriteMap<Node,Arc>())
+ .distMap(concepts::ReadWriteMap<Node,Value>())
+ .run(Node());
+ b=bellmanFord(g,LengthMap())
+ .predMap(concepts::ReadWriteMap<Node,Arc>())
+ .distMap(concepts::ReadWriteMap<Node,Value>())
+ .path(concepts::Path<Digraph>())
+ .dist(Value())
+ .run(Node(),Node());
+}
+
+
+template <typename Digraph, typename Value>
+void checkBellmanFord() {
+ TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+ typedef typename Digraph::template ArcMap<Value> LengthMap;
+
+ Digraph gr;
+ Node s, t;
+ LengthMap length(gr);
+
+ std::istringstream input(test_lgf);
+ digraphReader(gr, input).
+ arcMap("length", length).
+ node("source", s).
+ node("target", t).
+ run();
+
+ BellmanFord<Digraph, LengthMap>
+ bf(gr, length);
+ bf.run(s);
+ Path<Digraph> p = bf.path(t);
+
+ check(bf.reached(t) && bf.dist(t) == -1, "Bellman-Ford found a wrong path.");
+ check(p.length() == 3, "path() found a wrong path.");
+ check(checkPath(gr, p), "path() found a wrong path.");
+ check(pathSource(gr, p) == s, "path() found a wrong path.");
+ check(pathTarget(gr, p) == t, "path() found a wrong path.");
+
+ ListPath<Digraph> path;
+ Value dist;
+ bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
+
+ check(reached && dist == -1, "Bellman-Ford found a wrong path.");
+ check(path.length() == 3, "path() found a wrong path.");
+ check(checkPath(gr, path), "path() found a wrong path.");
+ check(pathSource(gr, path) == s, "path() found a wrong path.");
+ check(pathTarget(gr, path) == t, "path() found a wrong path.");
+
+ for(ArcIt e(gr); e!=INVALID; ++e) {
+ Node u=gr.source(e);
+ Node v=gr.target(e);
+ check(!bf.reached(u) || (bf.dist(v) - bf.dist(u) <= length[e]),
+ "Wrong output. dist(target)-dist(source)-arc_length=" <<
+ bf.dist(v) - bf.dist(u) - length[e]);
+ }
+
+ for(NodeIt v(gr); v!=INVALID; ++v) {
+ if (bf.reached(v)) {
+ check(v==s || bf.predArc(v)!=INVALID, "Wrong tree.");
+ if (bf.predArc(v)!=INVALID ) {
+ Arc e=bf.predArc(v);
+ Node u=gr.source(e);
+ check(u==bf.predNode(v),"Wrong tree.");
+ check(bf.dist(v) - bf.dist(u) == length[e],
+ "Wrong distance! Difference: " <<
+ bf.dist(v) - bf.dist(u) - length[e]);
+ }
+ }
+ }
+}
+
+void checkBellmanFordNegativeCycle() {
+ DIGRAPH_TYPEDEFS(SmartDigraph);
+
+ SmartDigraph gr;
+ IntArcMap length(gr);
+
+ Node n1 = gr.addNode();
+ Node n2 = gr.addNode();
+ Node n3 = gr.addNode();
+ Node n4 = gr.addNode();
+
+ Arc a1 = gr.addArc(n1, n2);
+ Arc a2 = gr.addArc(n2, n2);
+
+ length[a1] = 2;
+ length[a2] = -1;
+
+ {
+ BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
+ bf.run(n1);
+ StaticPath<SmartDigraph> p = bf.negativeCycle();
+ check(p.length() == 1 && p.front() == p.back() && p.front() == a2,
+ "Wrong negative cycle.");
+ }
+
+ length[a2] = 0;
+
+ {
+ BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
+ bf.run(n1);
+ check(bf.negativeCycle().empty(),
+ "Negative cycle should not be found.");
+ }
+
+ length[gr.addArc(n1, n3)] = 5;
+ length[gr.addArc(n4, n3)] = 1;
+ length[gr.addArc(n2, n4)] = 2;
+ length[gr.addArc(n3, n2)] = -4;
+
+ {
+ BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
+ bf.init();
+ bf.addSource(n1);
+ for (int i = 0; i < 4; ++i) {
+ check(bf.negativeCycle().empty(),
+ "Negative cycle should not be found.");
+ bf.processNextRound();
+ }
+ StaticPath<SmartDigraph> p = bf.negativeCycle();
+ check(p.length() == 3, "Wrong negative cycle.");
+ check(length[p.nth(0)] + length[p.nth(1)] + length[p.nth(2)] == -1,
+ "Wrong negative cycle.");
+ }
+}
+
+int main() {
+ checkBellmanFord<ListDigraph, int>();
+ checkBellmanFord<SmartDigraph, double>();
+ checkBellmanFordNegativeCycle();
+ return 0;
+}
diff -r e746fb14e680 -r 432c54cec63c test/circulation_test.cc
--- a/test/circulation_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/circulation_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -87,6 +87,11 @@
.upperMap(ucap)
.supplyMap(supply)
.flowMap(flow);
+
+ const CirculationType::Elevator& elev = const_circ_test.elevator();
+ circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
+ CirculationType::Tolerance tol = const_circ_test.tolerance();
+ circ_test.tolerance(tol);
circ_test.init();
circ_test.greedyInit();
diff -r e746fb14e680 -r 432c54cec63c test/digraph_test.cc
--- a/test/digraph_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/digraph_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -35,6 +35,9 @@
checkGraphNodeList(G, 0);
checkGraphArcList(G, 0);
+ G.reserveNode(3);
+ G.reserveArc(4);
+
Node
n1 = G.addNode(),
n2 = G.addNode(),
@@ -283,6 +286,14 @@
G.addArc(G.addNode(), G.addNode());
snapshot.restore();
+ snapshot.save(G);
+
+ checkGraphNodeList(G, 4);
+ checkGraphArcList(G, 4);
+
+ G.addArc(G.addNode(), G.addNode());
+
+ snapshot.restore();
checkGraphNodeList(G, 4);
checkGraphArcList(G, 4);
@@ -375,7 +386,12 @@
void checkFullDigraph(int num) {
typedef FullDigraph Digraph;
DIGRAPH_TYPEDEFS(Digraph);
+
Digraph G(num);
+ check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
+
+ G.resize(num);
+ check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
checkGraphNodeList(G, num);
checkGraphArcList(G, num * num);
diff -r e746fb14e680 -r 432c54cec63c test/graph_test.cc
--- a/test/graph_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/graph_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -38,6 +38,9 @@
checkGraphEdgeList(G, 0);
checkGraphArcList(G, 0);
+ G.reserveNode(3);
+ G.reserveEdge(3);
+
Node
n1 = G.addNode(),
n2 = G.addNode(),
@@ -256,6 +259,15 @@
G.addEdge(G.addNode(), G.addNode());
snapshot.restore();
+ snapshot.save(G);
+
+ checkGraphNodeList(G, 4);
+ checkGraphEdgeList(G, 3);
+ checkGraphArcList(G, 6);
+
+ G.addEdge(G.addNode(), G.addNode());
+
+ snapshot.restore();
checkGraphNodeList(G, 4);
checkGraphEdgeList(G, 3);
@@ -267,6 +279,13 @@
GRAPH_TYPEDEFS(Graph);
Graph G(num);
+ check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
+ "Wrong size");
+
+ G.resize(num);
+ check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
+ "Wrong size");
+
checkGraphNodeList(G, num);
checkGraphEdgeList(G, num * (num - 1) / 2);
@@ -411,6 +430,10 @@
check(G.width() == width, "Wrong column number");
check(G.height() == height, "Wrong row number");
+ G.resize(width, height);
+ check(G.width() == width, "Wrong column number");
+ check(G.height() == height, "Wrong row number");
+
for (int i = 0; i < width; ++i) {
for (int j = 0; j < height; ++j) {
check(G.col(G(i, j)) == i, "Wrong column");
@@ -486,6 +509,11 @@
GRAPH_TYPEDEFS(HypercubeGraph);
HypercubeGraph G(dim);
+ check(G.dimension() == dim, "Wrong dimension");
+
+ G.resize(dim);
+ check(G.dimension() == dim, "Wrong dimension");
+
checkGraphNodeList(G, 1 << dim);
checkGraphEdgeList(G, dim * (1 << (dim-1)));
checkGraphArcList(G, dim * (1 << dim));
diff -r e746fb14e680 -r 432c54cec63c test/heap_test.cc
--- a/test/heap_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/heap_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -25,14 +25,17 @@
#include <lemon/concepts/heap.h>
#include <lemon/smart_graph.h>
-
#include <lemon/lgf_reader.h>
#include <lemon/dijkstra.h>
#include <lemon/maps.h>
#include <lemon/bin_heap.h>
+#include <lemon/fourary_heap.h>
+#include <lemon/kary_heap.h>
#include <lemon/fib_heap.h>
+#include <lemon/pairing_heap.h>
#include <lemon/radix_heap.h>
+#include <lemon/binom_heap.h>
#include <lemon/bucket_heap.h>
#include "test_tools.h"
@@ -89,18 +92,16 @@
template <typename Heap>
void heapSortTest() {
RangeMap<int> map(test_len, -1);
-
Heap heap(map);
std::vector<int> v(test_len);
-
for (int i = 0; i < test_len; ++i) {
v[i] = test_seq[i];
heap.push(i, v[i]);
}
std::sort(v.begin(), v.end());
for (int i = 0; i < test_len; ++i) {
- check(v[i] == heap.prio() ,"Wrong order in heap sort.");
+ check(v[i] == heap.prio(), "Wrong order in heap sort.");
heap.pop();
}
}
@@ -112,7 +113,6 @@
Heap heap(map);
std::vector<int> v(test_len);
-
for (int i = 0; i < test_len; ++i) {
v[i] = test_seq[i];
heap.push(i, v[i]);
@@ -123,13 +123,11 @@
}
std::sort(v.begin(), v.end());
for (int i = 0; i < test_len; ++i) {
- check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
+ check(v[i] == heap.prio(), "Wrong order in heap increase test.");
heap.pop();
}
}
-
-
template <typename Heap>
void dijkstraHeapTest(const Digraph& digraph, const IntArcMap& length,
Node source) {
@@ -144,7 +142,7 @@
Node t = digraph.target(a);
if (dijkstra.reached(s)) {
check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
- "Error in a shortest path tree!");
+ "Error in shortest path tree.");
}
}
@@ -153,7 +151,7 @@
Arc a = dijkstra.predArc(n);
Node s = digraph.source(a);
check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
- "Error in a shortest path tree!");
+ "Error in shortest path tree.");
}
}
@@ -175,6 +173,7 @@
node("source", source).
run();
+ // BinHeap
{
typedef BinHeap<Prio, ItemIntMap> IntHeap;
checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
@@ -186,6 +185,31 @@
dijkstraHeapTest<NodeHeap>(digraph, length, source);
}
+ // FouraryHeap
+ {
+ typedef FouraryHeap<Prio, ItemIntMap> IntHeap;
+ checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+ heapSortTest<IntHeap>();
+ heapIncreaseTest<IntHeap>();
+
+ typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;
+ checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+ dijkstraHeapTest<NodeHeap>(digraph, length, source);
+ }
+
+ // KaryHeap
+ {
+ typedef KaryHeap<Prio, ItemIntMap> IntHeap;
+ checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+ heapSortTest<IntHeap>();
+ heapIncreaseTest<IntHeap>();
+
+ typedef KaryHeap<Prio, IntNodeMap > NodeHeap;
+ checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+ dijkstraHeapTest<NodeHeap>(digraph, length, source);
+ }
+
+ // FibHeap
{
typedef FibHeap<Prio, ItemIntMap> IntHeap;
checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
@@ -197,6 +221,19 @@
dijkstraHeapTest<NodeHeap>(digraph, length, source);
}
+ // PairingHeap
+ {
+ typedef PairingHeap<Prio, ItemIntMap> IntHeap;
+ checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+ heapSortTest<IntHeap>();
+ heapIncreaseTest<IntHeap>();
+
+ typedef PairingHeap<Prio, IntNodeMap > NodeHeap;
+ checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+ dijkstraHeapTest<NodeHeap>(digraph, length, source);
+ }
+
+ // RadixHeap
{
typedef RadixHeap<ItemIntMap> IntHeap;
checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
@@ -208,6 +245,19 @@
dijkstraHeapTest<NodeHeap>(digraph, length, source);
}
+ // BinomHeap
+ {
+ typedef BinomHeap<Prio, ItemIntMap> IntHeap;
+ checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
+ heapSortTest<IntHeap>();
+ heapIncreaseTest<IntHeap>();
+
+ typedef BinomHeap<Prio, IntNodeMap > NodeHeap;
+ checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
+ dijkstraHeapTest<NodeHeap>(digraph, length, source);
+ }
+
+ // BucketHeap, SimpleBucketHeap
{
typedef BucketHeap<ItemIntMap> IntHeap;
checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
@@ -217,8 +267,10 @@
typedef BucketHeap<IntNodeMap > NodeHeap;
checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
dijkstraHeapTest<NodeHeap>(digraph, length, source);
+
+ typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap;
+ heapSortTest<SimpleIntHeap>();
}
-
return 0;
}
diff -r e746fb14e680 -r 432c54cec63c test/maps_test.cc
--- a/test/maps_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/maps_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -22,6 +22,10 @@
#include <lemon/concept_check.h>
#include <lemon/concepts/maps.h>
#include <lemon/maps.h>
+#include <lemon/list_graph.h>
+#include <lemon/smart_graph.h>
+#include <lemon/adaptors.h>
+#include <lemon/dfs.h>
#include "test_tools.h"
@@ -60,6 +64,12 @@
typedef ReadWriteMap<A, bool> BoolWriteMap;
typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap;
+template<typename Map1, typename Map2, typename ItemIt>
+void compareMap(const Map1& map1, const Map2& map2, ItemIt it) {
+ for (; it != INVALID; ++it)
+ check(map1[it] == map2[it], "The maps are not equal");
+}
+
int main()
{
// Map concepts
@@ -328,6 +338,10 @@
// LoggerBoolMap
{
typedef std::vector<int> vec;
+ checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();
+ checkConcept<WriteMap<int, bool>,
+ LoggerBoolMap<std::back_insert_iterator<vec> > >();
+
vec v1;
vec v2(10);
LoggerBoolMap<std::back_insert_iterator<vec> >
@@ -347,7 +361,444 @@
for ( LoggerBoolMap<vec::iterator>::Iterator it = map2.begin();
it != map2.end(); ++it )
check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
+
+ typedef ListDigraph Graph;
+ DIGRAPH_TYPEDEFS(Graph);
+ Graph gr;
+
+ Node n0 = gr.addNode();
+ Node n1 = gr.addNode();
+ Node n2 = gr.addNode();
+ Node n3 = gr.addNode();
+
+ gr.addArc(n3, n0);
+ gr.addArc(n3, n2);
+ gr.addArc(n0, n2);
+ gr.addArc(n2, n1);
+ gr.addArc(n0, n1);
+
+ {
+ std::vector<Node> v;
+ dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
+
+ check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
+ "Something is wrong with LoggerBoolMap");
+ }
+ {
+ std::vector<Node> v(countNodes(gr));
+ dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
+
+ check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
+ "Something is wrong with LoggerBoolMap");
+ }
+ }
+
+ // IdMap, RangeIdMap
+ {
+ typedef ListDigraph Graph;
+ DIGRAPH_TYPEDEFS(Graph);
+
+ checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
+ checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
+ checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
+ checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
+
+ Graph gr;
+ IdMap<Graph, Node> nmap(gr);
+ IdMap<Graph, Arc> amap(gr);
+ RangeIdMap<Graph, Node> nrmap(gr);
+ RangeIdMap<Graph, Arc> armap(gr);
+
+ Node n0 = gr.addNode();
+ Node n1 = gr.addNode();
+ Node n2 = gr.addNode();
+
+ Arc a0 = gr.addArc(n0, n1);
+ Arc a1 = gr.addArc(n0, n2);
+ Arc a2 = gr.addArc(n2, n1);
+ Arc a3 = gr.addArc(n2, n0);
+
+ check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
+ check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
+ check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
+
+ check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
+ check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
+ check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
+ check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
+
+ check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
+ check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
+
+ check(nrmap.size() == 3 && armap.size() == 4,
+ "Wrong RangeIdMap::size()");
+
+ check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
+ check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
+ check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
+
+ check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
+ check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
+ check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
+ check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
+
+ check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
+ check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
+
+ gr.erase(n1);
+
+ if (nrmap[n0] == 1) nrmap.swap(n0, n2);
+ nrmap.swap(n2, n0);
+ if (armap[a1] == 1) armap.swap(a1, a3);
+ armap.swap(a3, a1);
+
+ check(nrmap.size() == 2 && armap.size() == 2,
+ "Wrong RangeIdMap::size()");
+
+ check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
+ check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
+
+ check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
+ check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
+
+ check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
+ check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
+ }
+
+ // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
+ {
+ typedef ListGraph Graph;
+ GRAPH_TYPEDEFS(Graph);
+
+ checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
+ checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
+ checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
+ checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
+ checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
+ checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
+
+ Graph gr;
+ Node n0 = gr.addNode();
+ Node n1 = gr.addNode();
+ Node n2 = gr.addNode();
+
+ gr.addEdge(n0,n1);
+ gr.addEdge(n1,n2);
+ gr.addEdge(n0,n2);
+ gr.addEdge(n2,n1);
+ gr.addEdge(n1,n2);
+ gr.addEdge(n0,n1);
+
+ for (EdgeIt e(gr); e != INVALID; ++e) {
+ check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
+ check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
+ }
+
+ compareMap(sourceMap(orienter(gr, constMap<Edge, bool>(true))),
+ targetMap(orienter(gr, constMap<Edge, bool>(false))),
+ EdgeIt(gr));
+
+ typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
+ Digraph dgr(gr, constMap<Edge, bool>(true));
+ OutDegMap<Digraph> odm(dgr);
+ InDegMap<Digraph> idm(dgr);
+
+ check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
+ check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
+
+ gr.addEdge(n2, n0);
+
+ check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
+ check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
+ }
+
+ // CrossRefMap
+ {
+ typedef ListDigraph Graph;
+ DIGRAPH_TYPEDEFS(Graph);
+
+ checkConcept<ReadWriteMap<Node, int>,
+ CrossRefMap<Graph, Node, int> >();
+ checkConcept<ReadWriteMap<Node, bool>,
+ CrossRefMap<Graph, Node, bool> >();
+ checkConcept<ReadWriteMap<Node, double>,
+ CrossRefMap<Graph, Node, double> >();
+
+ Graph gr;
+ typedef CrossRefMap<Graph, Node, char> CRMap;
+ CRMap map(gr);
+
+ Node n0 = gr.addNode();
+ Node n1 = gr.addNode();
+ Node n2 = gr.addNode();
+
+ map.set(n0, 'A');
+ map.set(n1, 'B');
+ map.set(n2, 'C');
+
+ check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
+ "Wrong CrossRefMap");
+ check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
+ "Wrong CrossRefMap");
+ check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
+ "Wrong CrossRefMap");
+ check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
+ "Wrong CrossRefMap::count()");
+
+ CRMap::ValueIt it = map.beginValue();
+ check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
+ it == map.endValue(), "Wrong value iterator");
+
+ map.set(n2, 'A');
+
+ check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
+ "Wrong CrossRefMap");
+ check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
+ check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
+ check(map('C') == INVALID && map.inverse()['C'] == INVALID,
+ "Wrong CrossRefMap");
+ check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,
+ "Wrong CrossRefMap::count()");
+
+ it = map.beginValue();
+ check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&
+ it == map.endValue(), "Wrong value iterator");
+
+ map.set(n0, 'C');
+
+ check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
+ "Wrong CrossRefMap");
+ check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
+ check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
+ check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
+ check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
+ "Wrong CrossRefMap::count()");
+
+ it = map.beginValue();
+ check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
+ it == map.endValue(), "Wrong value iterator");
}
+ // CrossRefMap
+ {
+ typedef SmartDigraph Graph;
+ DIGRAPH_TYPEDEFS(Graph);
+
+ checkConcept<ReadWriteMap<Node, int>,
+ CrossRefMap<Graph, Node, int> >();
+
+ Graph gr;
+ typedef CrossRefMap<Graph, Node, char> CRMap;
+ typedef CRMap::ValueIterator ValueIt;
+ CRMap map(gr);
+
+ Node n0 = gr.addNode();
+ Node n1 = gr.addNode();
+ Node n2 = gr.addNode();
+
+ map.set(n0, 'A');
+ map.set(n1, 'B');
+ map.set(n2, 'C');
+ map.set(n2, 'A');
+ map.set(n0, 'C');
+
+ check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
+ "Wrong CrossRefMap");
+ check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
+ check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
+ check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
+
+ ValueIt it = map.beginValue();
+ check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
+ it == map.endValue(), "Wrong value iterator");
+ }
+
+ // Iterable bool map
+ {
+ typedef SmartGraph Graph;
+ typedef SmartGraph::Node Item;
+
+ typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;
+ checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();
+
+ const int num = 10;
+ Graph g;
+ std::vector<Item> items;
+ for (int i = 0; i < num; ++i) {
+ items.push_back(g.addNode());
+ }
+
+ Ibm map1(g, true);
+ int n = 0;
+ for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)], "Wrong TrueIt");
+ ++n;
+ }
+ check(n == num, "Wrong number");
+
+ n = 0;
+ for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
+ ++n;
+ }
+ check(n == num, "Wrong number");
+ check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt");
+ check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false");
+
+ map1[items[5]] = true;
+
+ n = 0;
+ for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
+ ++n;
+ }
+ check(n == num, "Wrong number");
+
+ map1[items[num / 2]] = false;
+ check(map1[items[num / 2]] == false, "Wrong map value");
+
+ n = 0;
+ for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
+ ++n;
+ }
+ check(n == num - 1, "Wrong number");
+
+ n = 0;
+ for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
+ check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
+ ++n;
+ }
+ check(n == 1, "Wrong number");
+
+ map1[items[0]] = false;
+ check(map1[items[0]] == false, "Wrong map value");
+
+ map1[items[num - 1]] = false;
+ check(map1[items[num - 1]] == false, "Wrong map value");
+
+ n = 0;
+ for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
+ ++n;
+ }
+ check(n == num - 3, "Wrong number");
+ check(map1.trueNum() == num - 3, "Wrong number");
+
+ n = 0;
+ for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
+ check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
+ ++n;
+ }
+ check(n == 3, "Wrong number");
+ check(map1.falseNum() == 3, "Wrong number");
+ }
+
+ // Iterable int map
+ {
+ typedef SmartGraph Graph;
+ typedef SmartGraph::Node Item;
+ typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim;
+
+ checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>();
+
+ const int num = 10;
+ Graph g;
+ std::vector<Item> items;
+ for (int i = 0; i < num; ++i) {
+ items.push_back(g.addNode());
+ }
+
+ Iim map1(g);
+ check(map1.size() == 0, "Wrong size");
+
+ for (int i = 0; i < num; ++i) {
+ map1[items[i]] = i;
+ }
+ check(map1.size() == num, "Wrong size");
+
+ for (int i = 0; i < num; ++i) {
+ Iim::ItemIt it(map1, i);
+ check(static_cast<Item>(it) == items[i], "Wrong value");
+ ++it;
+ check(static_cast<Item>(it) == INVALID, "Wrong value");
+ }
+
+ for (int i = 0; i < num; ++i) {
+ map1[items[i]] = i % 2;
+ }
+ check(map1.size() == 2, "Wrong size");
+
+ int n = 0;
+ for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)] == 0, "Wrong value");
+ ++n;
+ }
+ check(n == (num + 1) / 2, "Wrong number");
+
+ for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)] == 1, "Wrong value");
+ ++n;
+ }
+ check(n == num, "Wrong number");
+
+ }
+
+ // Iterable value map
+ {
+ typedef SmartGraph Graph;
+ typedef SmartGraph::Node Item;
+ typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm;
+
+ checkConcept<ReadWriteMap<Item, double>, Ivm>();
+
+ const int num = 10;
+ Graph g;
+ std::vector<Item> items;
+ for (int i = 0; i < num; ++i) {
+ items.push_back(g.addNode());
+ }
+
+ Ivm map1(g, 0.0);
+ check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size");
+ check(*map1.beginValue() == 0.0, "Wrong value");
+
+ for (int i = 0; i < num; ++i) {
+ map1.set(items[i], static_cast<double>(i));
+ }
+ check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size");
+
+ for (int i = 0; i < num; ++i) {
+ Ivm::ItemIt it(map1, static_cast<double>(i));
+ check(static_cast<Item>(it) == items[i], "Wrong value");
+ ++it;
+ check(static_cast<Item>(it) == INVALID, "Wrong value");
+ }
+
+ for (Ivm::ValueIt vit = map1.beginValue();
+ vit != map1.endValue(); ++vit) {
+ check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
+ "Wrong ValueIt");
+ }
+
+ for (int i = 0; i < num; ++i) {
+ map1.set(items[i], static_cast<double>(i % 2));
+ }
+ check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size");
+
+ int n = 0;
+ for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)] == 0.0, "Wrong value");
+ ++n;
+ }
+ check(n == (num + 1) / 2, "Wrong number");
+
+ for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {
+ check(map1[static_cast<Item>(it)] == 1.0, "Wrong value");
+ ++n;
+ }
+ check(n == num, "Wrong number");
+
+ }
return 0;
}
diff -r e746fb14e680 -r 432c54cec63c test/mip_test.cc
--- a/test/mip_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/mip_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -50,7 +50,8 @@
if (stat == MipSolver::OPTIMAL) {
std::ostringstream sbuf;
- buf << "Wrong optimal value: the right optimum is " << exp_opt;
+ sbuf << "Wrong optimal value ("<< mip.solValue()
+ <<" instead of " << exp_opt << ")";
check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
//+ecvt(exp_opt,2)
}
diff -r e746fb14e680 -r 432c54cec63c test/preflow_test.cc
--- a/test/preflow_test.cc Tue Aug 18 10:08:28 2009 +0200
+++ b/test/preflow_test.cc Thu Nov 05 08:39:49 2009 +0100
@@ -94,6 +94,11 @@
::Create PreflowType;
PreflowType preflow_test(g, cap, n, n);
const PreflowType& const_preflow_test = preflow_test;
+
+ const PreflowType::Elevator& elev = const_preflow_test.elevator();
+ preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
+ PreflowType::Tolerance tol = const_preflow_test.tolerance();
+ preflow_test.tolerance(tol);
preflow_test
.capacityMap(cap)
diff -r e746fb14e680 -r 432c54cec63c tools/lemon-0.x-to-1.x.sh
--- a/tools/lemon-0.x-to-1.x.sh Tue Aug 18 10:08:28 2009 +0200
+++ b/tools/lemon-0.x-to-1.x.sh Thu Nov 05 08:39:49 2009 +0100
@@ -35,10 +35,10 @@
-e "s/IncEdgeIt/_In_cEd_geIt_label_/g"\
-e "s/Edge\>/_Ar_c_label_/g"\
-e "s/\<edge\>/_ar_c_label_/g"\
- -e "s/_edge\>/_ar_c_label_/g"\
+ -e "s/_edge\>/__ar_c_label_/g"\
-e "s/Edges\>/_Ar_c_label_s/g"\
-e "s/\<edges\>/_ar_c_label_s/g"\
- -e "s/_edges\>/_ar_c_label_s/g"\
+ -e "s/_edges\>/__ar_c_label_s/g"\
-e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\
-e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\
-e "s/Edge/_Ar_c_label_/g"\
@@ -68,6 +68,11 @@
-e "s/_blu_e_label_/blue/g"\
-e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\
-e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\
+ -e "s/\<digraph_adaptor\.h\>/adaptors.h/g"\
+ -e "s/\<digraph_utils\.h\>/core.h/g"\
+ -e "s/\<digraph_reader\.h\>/lgf_reader.h/g"\
+ -e "s/\<digraph_writer\.h\>/lgf_writer.h/g"\
+ -e "s/\<topology\.h\>/connectivity.h/g"\
-e "s/DigraphToEps/GraphToEps/g"\
-e "s/digraphToEps/graphToEps/g"\
-e "s/\<DefPredMap\>/SetPredMap/g"\