Index: CMakeLists.txt =================================================================== --- CMakeLists.txt (revision 744) +++ CMakeLists.txt (revision 680) @@ -35,6 +35,4 @@ CHECK_TYPE_SIZE("long long" LONG_LONG) SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) - -INCLUDE(FindPythonInterp) ENABLE_TESTING() Index: Makefile.am =================================================================== --- Makefile.am (revision 629) +++ Makefile.am (revision 752) @@ -18,4 +18,5 @@ cmake/FindGLPK.cmake \ cmake/FindCOIN.cmake \ + cmake/LEMONConfig.cmake.in \ cmake/version.cmake.in \ cmake/version.cmake \ Index: configure.ac =================================================================== --- configure.ac (revision 744) +++ configure.ac (revision 680) @@ -42,5 +42,4 @@ AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) -AC_CHECK_PROG([python_found],[python],[yes],[no]) AC_CHECK_PROG([gs_found],[gs],[yes],[no]) Index: doc/CMakeLists.txt =================================================================== --- doc/CMakeLists.txt (revision 744) +++ doc/CMakeLists.txt (revision 679) @@ -10,5 +10,5 @@ ) -IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE) +IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE) FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/) SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha) @@ -29,5 +29,4 @@ COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps COMMAND ${CMAKE_COMMAND} -E remove_directory html - COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} Index: doc/Doxyfile.in =================================================================== --- doc/Doxyfile.in (revision 744) +++ doc/Doxyfile.in (revision 367) @@ -92,6 +92,5 @@ "@abs_top_srcdir@/demo" \ "@abs_top_srcdir@/tools" \ - "@abs_top_srcdir@/test/test_tools.h" \ - "@abs_top_builddir@/doc/references.dox" + "@abs_top_srcdir@/test/test_tools.h" INPUT_ENCODING = UTF-8 FILE_PATTERNS = *.h \ Index: doc/Makefile.am =================================================================== --- doc/Makefile.am (revision 744) +++ doc/Makefile.am (revision 673) @@ -67,17 +67,5 @@ fi -references.dox: doc/references.bib - if test ${python_found} = yes; then \ - cd doc; \ - python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \ - cd ..; \ - else \ - echo; \ - echo "Python not found."; \ - echo; \ - exit 1; \ - fi - -html-local: $(DOC_PNG_IMAGES) references.dox +html-local: $(DOC_PNG_IMAGES) if test ${doxygen_found} = yes; then \ cd doc; \ Index: doc/groups.dox =================================================================== --- doc/groups.dox (revision 742) +++ doc/groups.dox (revision 663) @@ -227,4 +227,12 @@ /** +@defgroup matrices Matrices +@ingroup datas +\brief Two dimensional data storages implemented in LEMON. + +This group contains two dimensional data storages implemented in LEMON. +*/ + +/** @defgroup paths Path Structures @ingroup datas @@ -239,34 +247,5 @@ any kind of path structure. -\sa \ref concepts::Path "Path concept" -*/ - -/** -@defgroup heaps Heap Structures -@ingroup datas -\brief %Heap structures implemented in LEMON. - -This group contains the heap structures implemented in LEMON. - -LEMON provides several heap classes. They are efficient implementations -of the abstract data type \e priority \e queue. They store items with -specified values called \e priorities in such a way that finding and -removing the item with minimum priority are efficient. -The basic operations are adding and erasing items, changing the priority -of an item, etc. - -Heaps are crucial in several algorithms, such as Dijkstra and Prim. -The heap implementations have the same interface, thus any of them can be -used easily in such algorithms. - -\sa \ref concepts::Heap "Heap concept" -*/ - -/** -@defgroup matrices Matrices -@ingroup datas -\brief Two dimensional data storages implemented in LEMON. - -This group contains two dimensional data storages implemented in LEMON. +\sa lemon::concepts::Path */ @@ -278,26 +257,4 @@ This group contains some data structures implemented in LEMON in order to make it easier to implement combinatorial algorithms. -*/ - -/** -@defgroup geomdat Geometric Data Structures -@ingroup auxdat -\brief Geometric data structures implemented in LEMON. - -This group contains geometric data structures implemented in LEMON. - - - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional - vector with the usual operations. - - \ref lemon::dim2::Box "dim2::Box" can be used to determine the - rectangular bounding box of a set of \ref lemon::dim2::Point - "dim2::Point"'s. -*/ - -/** -@defgroup matrices Matrices -@ingroup auxdat -\brief Two dimensional data storages implemented in LEMON. - -This group contains two dimensional data storages implemented in LEMON. */ @@ -342,13 +299,4 @@ /** -@defgroup spantree Minimum Spanning Tree Algorithms -@ingroup algs -\brief Algorithms for finding minimum cost spanning trees and arborescences. - -This group contains the algorithms for finding minimum cost spanning -trees and arborescences. -*/ - -/** @defgroup max_flow Maximum Flow Algorithms @ingroup algs @@ -428,5 +376,5 @@ \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} - \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] + \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f] LEMON contains several algorithms related to minimum cut problems: @@ -441,4 +389,28 @@ If you want to find minimum cut just between two distinict nodes, see the \ref max_flow "maximum flow problem". +*/ + +/** +@defgroup graph_properties Connectivity and Other Graph Properties +@ingroup algs +\brief Algorithms for discovering the graph properties + +This group contains the algorithms for discovering the graph properties +like connectivity, bipartiteness, euler property, simplicity etc. + +\image html edge_biconnected_components.png +\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth +*/ + +/** +@defgroup planar Planarity Embedding and Drawing +@ingroup algs +\brief Algorithms for planarity checking, embedding and drawing + +This group contains the algorithms for planarity checking, +embedding and drawing. + +\image html planar.png +\image latex planar.eps "Plane graph" width=\textwidth */ @@ -484,25 +456,19 @@ /** -@defgroup graph_properties Connectivity and Other Graph Properties -@ingroup algs -\brief Algorithms for discovering the graph properties - -This group contains the algorithms for discovering the graph properties -like connectivity, bipartiteness, euler property, simplicity etc. - -\image html connected_components.png -\image latex connected_components.eps "Connected components" width=\textwidth -*/ - -/** -@defgroup planar Planarity Embedding and Drawing -@ingroup algs -\brief Algorithms for planarity checking, embedding and drawing - -This group contains the algorithms for planarity checking, -embedding and drawing. - -\image html planar.png -\image latex planar.eps "Plane graph" width=\textwidth +@defgroup spantree Minimum Spanning Tree Algorithms +@ingroup algs +\brief Algorithms for finding minimum cost spanning trees and arborescences. + +This group contains the algorithms for finding minimum cost spanning +trees and arborescences. +*/ + +/** +@defgroup auxalg Auxiliary Algorithms +@ingroup algs +\brief Auxiliary algorithms implemented in LEMON. + +This group contains some algorithms implemented in LEMON +in order to make it easier to implement complex algorithms. */ @@ -514,13 +480,4 @@ This group contains the approximation and heuristic algorithms implemented in LEMON. -*/ - -/** -@defgroup auxalg Auxiliary Algorithms -@ingroup algs -\brief Auxiliary algorithms implemented in LEMON. - -This group contains some algorithms implemented in LEMON -in order to make it easier to implement complex algorithms. */ @@ -631,5 +588,5 @@ /** -@defgroup dimacs_group DIMACS Format +@defgroup dimacs_group DIMACS format @ingroup io_group \brief Read and write files in DIMACS format @@ -680,6 +637,6 @@ \brief Skeleton and concept checking classes for graph structures -This group contains the skeletons and concept checking classes of -graph structures. +This group contains the skeletons and concept checking classes of LEMON's +graph structures and helper classes used to implement these. */ @@ -693,4 +650,16 @@ /** +\anchor demoprograms + +@defgroup demos Demo Programs + +Some demo programs are listed here. Their full source codes can be found in +the \c demo subdirectory of the source tree. + +In order to compile them, use the make demo or the +make check commands. +*/ + +/** @defgroup tools Standalone Utility Applications @@ -701,15 +670,3 @@ */ -/** -\anchor demoprograms - -@defgroup demos Demo Programs - -Some demo programs are listed here. Their full source codes can be found in -the \c demo subdirectory of the source tree. - -In order to compile them, use the make demo or the -make check commands. -*/ - } Index: c/references.bib =================================================================== --- doc/references.bib (revision 743) +++ (revision ) @@ -1,341 +1,0 @@ -%%%%% Defining LEMON %%%%% - -@misc{lemon, - key = {LEMON}, - title = {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and - {O}ptimization in {N}etworks}, - howpublished = {\url{http://lemon.cs.elte.hu/}}, - year = 2009 -} - -@misc{egres, - key = {EGRES}, - title = {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on - {C}ombinatorial {O}ptimization}, - howpublished = {\url{http://www.cs.elte.hu/egres/}}, - year = 2009 -} - -@misc{coinor, - key = {COIN-OR}, - title = {{COIN-OR} -- {C}omputational {I}nfrastructure for - {O}perations {R}esearch}, - howpublished = {\url{http://www.coin-or.org/}}, - year = 2009 -} - - -%%%%% Other libraries %%%%%% - -@misc{boost, - key = {Boost}, - title = {{B}oost {C++} {L}ibraries}, - howpublished = {\url{http://www.boost.org/}}, - year = 2009 -} - -@book{bglbook, - author = {Jeremy G. Siek and Lee-Quan Lee and Andrew - Lumsdaine}, - title = {The Boost Graph Library: User Guide and Reference - Manual}, - publisher = {Addison-Wesley}, - year = 2002 -} - -@misc{leda, - key = {LEDA}, - title = {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and - {A}lgorithms}, - howpublished = {\url{http://www.algorithmic-solutions.com/}}, - year = 2009 -} - -@book{ledabook, - author = {Kurt Mehlhorn and Stefan N{\"a}her}, - title = {{LEDA}: {A} platform for combinatorial and geometric - computing}, - isbn = {0-521-56329-1}, - publisher = {Cambridge University Press}, - address = {New York, NY, USA}, - year = 1999 -} - - -%%%%% Tools that LEMON depends on %%%%% - -@misc{cmake, - key = {CMake}, - title = {{CMake} -- {C}ross {P}latform {M}ake}, - howpublished = {\url{http://www.cmake.org/}}, - year = 2009 -} - -@misc{doxygen, - key = {Doxygen}, - title = {{Doxygen} -- {S}ource code documentation generator - tool}, - howpublished = {\url{http://www.doxygen.org/}}, - year = 2009 -} - - -%%%%% LP/MIP libraries %%%%% - -@misc{glpk, - key = {GLPK}, - title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it}, - howpublished = {\url{http://www.gnu.org/software/glpk/}}, - year = 2009 -} - -@misc{clp, - key = {Clp}, - title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming}, - howpublished = {\url{http://projects.coin-or.org/Clp/}}, - year = 2009 -} - -@misc{cbc, - key = {Cbc}, - title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut}, - howpublished = {\url{http://projects.coin-or.org/Cbc/}}, - year = 2009 -} - -@misc{cplex, - key = {CPLEX}, - title = {{ILOG} {CPLEX}}, - howpublished = {\url{http://www.ilog.com/}}, - year = 2009 -} - -@misc{soplex, - key = {SoPlex}, - title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented - {S}implex}, - howpublished = {\url{http://soplex.zib.de/}}, - year = 2009 -} - - -%%%%% General books %%%%% - -@book{amo93networkflows, - author = {Ravindra K. Ahuja and Thomas L. Magnanti and James - B. Orlin}, - title = {Network Flows: Theory, Algorithms, and Applications}, - publisher = {Prentice-Hall, Inc.}, - year = 1993, - month = feb, - isbn = {978-0136175490} -} - -@book{schrijver03combinatorial, - author = {Alexander Schrijver}, - title = {Combinatorial Optimization: Polyhedra and Efficiency}, - publisher = {Springer-Verlag}, - year = 2003, - isbn = {978-3540443896} -} - -@book{clrs01algorithms, - author = {Thomas H. Cormen and Charles E. Leiserson and Ronald - L. Rivest and Clifford Stein}, - title = {Introduction to Algorithms}, - publisher = {The MIT Press}, - year = 2001, - edition = {2nd} -} - -@book{stroustrup00cpp, - author = {Bjarne Stroustrup}, - title = {The C++ Programming Language}, - edition = {3rd}, - publisher = {Addison-Wesley Professional}, - isbn = 0201700735, - month = {February}, - year = 2000 -} - - -%%%%% Maximum flow algorithms %%%%% - -@inproceedings{goldberg86newapproach, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {A new approach to the maximum flow problem}, - booktitle = {STOC '86: Proceedings of the Eighteenth Annual ACM - Symposium on Theory of Computing}, - year = 1986, - publisher = {ACM Press}, - address = {New York, NY}, - pages = {136-146} -} - -@article{dinic70algorithm, - author = {E. A. Dinic}, - title = {Algorithm for solution of a problem of maximum flow - in a network with power estimation}, - journal = {Soviet Math. Doklady}, - year = 1970, - volume = 11, - pages = {1277-1280} -} - -@article{goldberg08partial, - author = {Andrew V. Goldberg}, - title = {The Partial Augment-Relabel Algorithm for the - Maximum Flow Problem}, - journal = {16th Annual European Symposium on Algorithms}, - year = 2008, - pages = {466-477} -} - -@article{sleator83dynamic, - author = {Daniel D. Sleator and Robert E. Tarjan}, - title = {A data structure for dynamic trees}, - journal = {Journal of Computer and System Sciences}, - year = 1983, - volume = 26, - number = 3, - pages = {362-391} -} - - -%%%%% Minimum mean cycle algorithms %%%%% - -@article{karp78characterization, - author = {Richard M. Karp}, - title = {A characterization of the minimum cycle mean in a - digraph}, - journal = {Discrete Math.}, - year = 1978, - volume = 23, - pages = {309-311} -} - -@article{dasdan98minmeancycle, - author = {Ali Dasdan and Rajesh K. Gupta}, - title = {Faster Maximum and Minimum Mean Cycle Alogrithms for - System Performance Analysis}, - journal = {IEEE Transactions on Computer-Aided Design of - Integrated Circuits and Systems}, - year = 1998, - volume = 17, - number = 10, - pages = {889-899} -} - - -%%%%% Minimum cost flow algorithms %%%%% - -@article{klein67primal, - author = {Morton Klein}, - title = {A primal method for minimal cost flows with - applications to the assignment and transportation - problems}, - journal = {Management Science}, - year = 1967, - volume = 14, - pages = {205-220} -} - -@inproceedings{goldberg88cyclecanceling, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {Finding minimum-cost circulations by canceling - negative cycles}, - booktitle = {STOC '88: Proceedings of the Twentieth Annual ACM - Symposium on Theory of Computing}, - year = 1988, - publisher = {ACM Press}, - address = {New York, NY}, - pages = {388-397} -} - -@article{edmondskarp72theoretical, - author = {Jack Edmonds and Richard M. Karp}, - title = {Theoretical improvements in algorithmic efficiency - for network flow problems}, - journal = {Journal of the ACM}, - year = 1972, - volume = 19, - number = 2, - pages = {248-264} -} - -@inproceedings{goldberg87approximation, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {Solving minimum-cost flow problems by successive - approximation}, - booktitle = {STOC '87: Proceedings of the Nineteenth Annual ACM - Symposium on Theory of Computing}, - year = 1987, - publisher = {ACM Press}, - address = {New York, NY}, - pages = {7-18} -} - -@article{goldberg90finding, - author = {Andrew V. Goldberg and Robert E. Tarjan}, - title = {Finding Minimum-Cost Circulations by Successive - Approximation}, - journal = {Mathematics of Operations Research}, - year = 1990, - volume = 15, - number = 3, - pages = {430-466} -} - -@article{goldberg97efficient, - author = {Andrew V. Goldberg}, - title = {An Efficient Implementation of a Scaling - Minimum-Cost Flow Algorithm}, - journal = {Journal of Algorithms}, - year = 1997, - volume = 22, - number = 1, - pages = {1-29} -} - -@article{bunnagel98efficient, - author = {Ursula B{\"u}nnagel and Bernhard Korte and Jens - Vygen}, - title = {Efficient implementation of the {G}oldberg-{T}arjan - minimum-cost flow algorithm}, - journal = {Optimization Methods and Software}, - year = 1998, - volume = 10, - pages = {157-174} -} - -@mastersthesis{kellyoneill91netsimplex, - author = {Damian J. Kelly and Garrett M. O'Neill}, - title = {The Minimum Cost Flow Problem and The Network - Simplex Method}, - school = {University College}, - address = {Dublin, Ireland}, - year = 1991, - month = sep, -} - -@techreport{lobel96networksimplex, - author = {Andreas L{\"o}bel}, - title = {Solving large-scale real-world minimum-cost flow - problems by a network simplex method}, - institution = {Konrad-Zuse-Zentrum fur Informationstechnik Berlin - ({ZIB})}, - address = {Berlin, Germany}, - year = 1996, - number = {SC 96-7} -} - -@article{frangioni06computational, - author = {Antonio Frangioni and Antonio Manca}, - title = {A Computational Study of Cost Reoptimization for - Min-Cost Flow Problems}, - journal = {INFORMS Journal On Computing}, - year = 2006, - volume = 18, - number = 1, - pages = {61-70} -} Index: lemon/Makefile.am =================================================================== --- lemon/Makefile.am (revision 708) +++ lemon/Makefile.am (revision 667) @@ -58,9 +58,6 @@ lemon/arg_parser.h \ lemon/assert.h \ - lemon/bellman_ford.h \ lemon/bfs.h \ lemon/bin_heap.h \ - lemon/binom_heap.h \ - lemon/bucket_heap.h \ lemon/cbc.h \ lemon/circulation.h \ @@ -80,6 +77,4 @@ lemon/error.h \ lemon/euler.h \ - lemon/fib_heap.h \ - lemon/fourary_heap.h \ lemon/full_graph.h \ lemon/glpk.h \ @@ -88,5 +83,4 @@ lemon/grid_graph.h \ lemon/hypercube_graph.h \ - lemon/kary_heap.h \ lemon/kruskal.h \ lemon/hao_orlin.h \ @@ -97,4 +91,5 @@ lemon/lp_base.h \ lemon/lp_skeleton.h \ + lemon/list_graph.h \ lemon/maps.h \ lemon/matching.h \ @@ -103,8 +98,6 @@ lemon/nauty_reader.h \ lemon/network_simplex.h \ - lemon/pairing_heap.h \ lemon/path.h \ lemon/preflow.h \ - lemon/radix_heap.h \ lemon/radix_sort.h \ lemon/random.h \ Index: mon/bellman_ford.h =================================================================== --- lemon/bellman_ford.h (revision 699) +++ (revision ) @@ -1,1100 +1,0 @@ -/* -*- C++ -*- - * - * This file is a part of LEMON, a generic C++ optimization library - * - * Copyright (C) 2003-2008 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BELLMAN_FORD_H -#define LEMON_BELLMAN_FORD_H - -/// \ingroup shortest_path -/// \file -/// \brief Bellman-Ford algorithm. - -#include -#include -#include -#include -#include - -#include - -namespace lemon { - - /// \brief Default OperationTraits for the BellmanFord algorithm class. - /// - /// This operation traits class defines all computational operations - /// and constants that are used in the Bellman-Ford algorithm. - /// The default implementation is based on the \c numeric_limits class. - /// If the numeric type does not have infinity value, then the maximum - /// value is used as extremal infinity value. - template < - typename V, - bool has_inf = std::numeric_limits::has_infinity> - struct BellmanFordDefaultOperationTraits { - /// \e - typedef V Value; - /// \brief Gives back the zero value of the type. - static Value zero() { - return static_cast(0); - } - /// \brief Gives back the positive infinity value of the type. - static Value infinity() { - return std::numeric_limits::infinity(); - } - /// \brief Gives back the sum of the given two elements. - static Value plus(const Value& left, const Value& right) { - return left + right; - } - /// \brief Gives back \c true only if the first value is less than - /// the second. - static bool less(const Value& left, const Value& right) { - return left < right; - } - }; - - template - struct BellmanFordDefaultOperationTraits { - typedef V Value; - static Value zero() { - return static_cast(0); - } - static Value infinity() { - return std::numeric_limits::max(); - } - static Value plus(const Value& left, const Value& right) { - if (left == infinity() || right == infinity()) return infinity(); - return left + right; - } - static bool less(const Value& left, const Value& right) { - return left < right; - } - }; - - /// \brief Default traits class of BellmanFord class. - /// - /// Default traits class of BellmanFord class. - /// \param GR The type of the digraph. - /// \param LEN The type of the length map. - template - struct BellmanFordDefaultTraits { - /// The type of the digraph the algorithm runs on. - typedef GR Digraph; - - /// \brief The type of the map that stores the arc lengths. - /// - /// The type of the map that stores the arc lengths. - /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. - typedef LEN LengthMap; - - /// The type of the arc lengths. - typedef typename LEN::Value Value; - - /// \brief Operation traits for Bellman-Ford algorithm. - /// - /// It defines the used operations and the infinity value for the - /// given \c Value type. - /// \see BellmanFordDefaultOperationTraits - typedef BellmanFordDefaultOperationTraits OperationTraits; - - /// \brief The type of the map that stores the last arcs of the - /// shortest paths. - /// - /// The type of the map that stores the last - /// arcs of the shortest paths. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap PredMap; - - /// \brief Instantiates a \c PredMap. - /// - /// This function instantiates a \ref PredMap. - /// \param g is the digraph to which we would like to define the - /// \ref PredMap. - static PredMap *createPredMap(const GR& g) { - return new PredMap(g); - } - - /// \brief The type of the map that stores the distances of the nodes. - /// - /// The type of the map that stores the distances of the nodes. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap DistMap; - - /// \brief Instantiates a \c DistMap. - /// - /// This function instantiates a \ref DistMap. - /// \param g is the digraph to which we would like to define the - /// \ref DistMap. - static DistMap *createDistMap(const GR& g) { - return new DistMap(g); - } - - }; - - /// \brief %BellmanFord algorithm class. - /// - /// \ingroup shortest_path - /// This class provides an efficient implementation of the Bellman-Ford - /// algorithm. The maximum time complexity of the algorithm is - /// O(ne). - /// - /// The Bellman-Ford algorithm solves the single-source shortest path - /// problem when the arcs can have negative lengths, but the digraph - /// should not contain directed cycles with negative total length. - /// If all arc costs are non-negative, consider to use the Dijkstra - /// algorithm instead, since it is more efficient. - /// - /// The arc lengths are passed to the algorithm using a - /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any - /// kind of length. The type of the length values is determined by the - /// \ref concepts::ReadMap::Value "Value" type of the length map. - /// - /// There is also a \ref bellmanFord() "function-type interface" for the - /// Bellman-Ford algorithm, which is convenient in the simplier cases and - /// it can be used easier. - /// - /// \tparam GR The type of the digraph the algorithm runs on. - /// The default type is \ref ListDigraph. - /// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies - /// the lengths of the arcs. The default map type is - /// \ref concepts::Digraph::ArcMap "GR::ArcMap". -#ifdef DOXYGEN - template -#else - template , - typename TR=BellmanFordDefaultTraits > -#endif - class BellmanFord { - public: - - ///The type of the underlying digraph. - typedef typename TR::Digraph Digraph; - - /// \brief The type of the arc lengths. - typedef typename TR::LengthMap::Value Value; - /// \brief The type of the map that stores the arc lengths. - typedef typename TR::LengthMap LengthMap; - /// \brief The type of the map that stores the last - /// arcs of the shortest paths. - typedef typename TR::PredMap PredMap; - /// \brief The type of the map that stores the distances of the nodes. - typedef typename TR::DistMap DistMap; - /// The type of the paths. - typedef PredMapPath Path; - ///\brief The \ref BellmanFordDefaultOperationTraits - /// "operation traits class" of the algorithm. - typedef typename TR::OperationTraits OperationTraits; - - ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm. - typedef TR Traits; - - private: - - typedef typename Digraph::Node Node; - typedef typename Digraph::NodeIt NodeIt; - typedef typename Digraph::Arc Arc; - typedef typename Digraph::OutArcIt OutArcIt; - - // Pointer to the underlying digraph. - const Digraph *_gr; - // Pointer to the length map - const LengthMap *_length; - // Pointer to the map of predecessors arcs. - PredMap *_pred; - // Indicates if _pred is locally allocated (true) or not. - bool _local_pred; - // Pointer to the map of distances. - DistMap *_dist; - // Indicates if _dist is locally allocated (true) or not. - bool _local_dist; - - typedef typename Digraph::template NodeMap MaskMap; - MaskMap *_mask; - - std::vector _process; - - // Creates the maps if necessary. - void create_maps() { - if(!_pred) { - _local_pred = true; - _pred = Traits::createPredMap(*_gr); - } - if(!_dist) { - _local_dist = true; - _dist = Traits::createDistMap(*_gr); - } - _mask = new MaskMap(*_gr, false); - } - - public : - - typedef BellmanFord Create; - - /// \name Named Template Parameters - - ///@{ - - template - struct SetPredMapTraits : public Traits { - typedef T PredMap; - static PredMap *createPredMap(const Digraph&) { - LEMON_ASSERT(false, "PredMap is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c PredMap type. - /// - /// \ref named-templ-param "Named parameter" for setting - /// \c PredMap type. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - template - struct SetPredMap - : public BellmanFord< Digraph, LengthMap, SetPredMapTraits > { - typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits > Create; - }; - - template - struct SetDistMapTraits : public Traits { - typedef T DistMap; - static DistMap *createDistMap(const Digraph&) { - LEMON_ASSERT(false, "DistMap is not initialized"); - return 0; // ignore warnings - } - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c DistMap type. - /// - /// \ref named-templ-param "Named parameter" for setting - /// \c DistMap type. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - template - struct SetDistMap - : public BellmanFord< Digraph, LengthMap, SetDistMapTraits > { - typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits > Create; - }; - - template - struct SetOperationTraitsTraits : public Traits { - typedef T OperationTraits; - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// \c OperationTraits type. - /// - /// \ref named-templ-param "Named parameter" for setting - /// \c OperationTraits type. - /// For more information see \ref BellmanFordDefaultOperationTraits. - template - struct SetOperationTraits - : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits > { - typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits > - Create; - }; - - ///@} - - protected: - - BellmanFord() {} - - public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param g The digraph the algorithm runs on. - /// \param length The length map used by the algorithm. - BellmanFord(const Digraph& g, const LengthMap& length) : - _gr(&g), _length(&length), - _pred(0), _local_pred(false), - _dist(0), _local_dist(false), _mask(0) {} - - ///Destructor. - ~BellmanFord() { - if(_local_pred) delete _pred; - if(_local_dist) delete _dist; - if(_mask) delete _mask; - } - - /// \brief Sets the length map. - /// - /// Sets the length map. - /// \return (*this) - BellmanFord &lengthMap(const LengthMap &map) { - _length = ↦ - return *this; - } - - /// \brief Sets the map that stores the predecessor arcs. - /// - /// Sets the map that stores the predecessor arcs. - /// If you don't use this function before calling \ref run() - /// or \ref init(), an instance will be allocated automatically. - /// The destructor deallocates this automatically allocated map, - /// of course. - /// \return (*this) - BellmanFord &predMap(PredMap &map) { - if(_local_pred) { - delete _pred; - _local_pred=false; - } - _pred = ↦ - return *this; - } - - /// \brief Sets the map that stores the distances of the nodes. - /// - /// Sets the map that stores the distances of the nodes calculated - /// by the algorithm. - /// If you don't use this function before calling \ref run() - /// or \ref init(), an instance will be allocated automatically. - /// The destructor deallocates this automatically allocated map, - /// of course. - /// \return (*this) - BellmanFord &distMap(DistMap &map) { - if(_local_dist) { - delete _dist; - _local_dist=false; - } - _dist = ↦ - return *this; - } - - /// \name Execution Control - /// The simplest way to execute the Bellman-Ford algorithm is to use - /// one of the member functions called \ref run().\n - /// If you need better control on the execution, you have to call - /// \ref init() first, then you can add several source nodes - /// with \ref addSource(). Finally the actual path computation can be - /// performed with \ref start(), \ref checkedStart() or - /// \ref limitedStart(). - - ///@{ - - /// \brief Initializes the internal data structures. - /// - /// Initializes the internal data structures. The optional parameter - /// is the initial distance of each node. - void init(const Value value = OperationTraits::infinity()) { - create_maps(); - for (NodeIt it(*_gr); it != INVALID; ++it) { - _pred->set(it, INVALID); - _dist->set(it, value); - } - _process.clear(); - if (OperationTraits::less(value, OperationTraits::infinity())) { - for (NodeIt it(*_gr); it != INVALID; ++it) { - _process.push_back(it); - _mask->set(it, true); - } - } - } - - /// \brief Adds a new source node. - /// - /// This function adds a new source node. The optional second parameter - /// is the initial distance of the node. - void addSource(Node source, Value dst = OperationTraits::zero()) { - _dist->set(source, dst); - if (!(*_mask)[source]) { - _process.push_back(source); - _mask->set(source, true); - } - } - - /// \brief Executes one round from the Bellman-Ford algorithm. - /// - /// If the algoritm calculated the distances in the previous round - /// exactly for the paths of at most \c k arcs, then this function - /// will calculate the distances exactly for the paths of at most - /// k+1 arcs. Performing \c k iterations using this function - /// calculates the shortest path distances exactly for the paths - /// consisting of at most \c k arcs. - /// - /// \warning The paths with limited arc number cannot be retrieved - /// easily with \ref path() or \ref predArc() functions. If you also - /// need the shortest paths and not only the distances, you should - /// store the \ref predMap() "predecessor map" after each iteration - /// and build the path manually. - /// - /// \return \c true when the algorithm have not found more shorter - /// paths. - /// - /// \see ActiveIt - bool processNextRound() { - for (int i = 0; i < int(_process.size()); ++i) { - _mask->set(_process[i], false); - } - std::vector nextProcess; - std::vector values(_process.size()); - for (int i = 0; i < int(_process.size()); ++i) { - values[i] = (*_dist)[_process[i]]; - } - for (int i = 0; i < int(_process.size()); ++i) { - for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { - Node target = _gr->target(it); - Value relaxed = OperationTraits::plus(values[i], (*_length)[it]); - if (OperationTraits::less(relaxed, (*_dist)[target])) { - _pred->set(target, it); - _dist->set(target, relaxed); - if (!(*_mask)[target]) { - _mask->set(target, true); - nextProcess.push_back(target); - } - } - } - } - _process.swap(nextProcess); - return _process.empty(); - } - - /// \brief Executes one weak round from the Bellman-Ford algorithm. - /// - /// If the algorithm calculated the distances in the previous round - /// at least for the paths of at most \c k arcs, then this function - /// will calculate the distances at least for the paths of at most - /// k+1 arcs. - /// This function does not make it possible to calculate the shortest - /// path distances exactly for paths consisting of at most \c k arcs, - /// this is why it is called weak round. - /// - /// \return \c true when the algorithm have not found more shorter - /// paths. - /// - /// \see ActiveIt - bool processNextWeakRound() { - for (int i = 0; i < int(_process.size()); ++i) { - _mask->set(_process[i], false); - } - std::vector nextProcess; - for (int i = 0; i < int(_process.size()); ++i) { - for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { - Node target = _gr->target(it); - Value relaxed = - OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]); - if (OperationTraits::less(relaxed, (*_dist)[target])) { - _pred->set(target, it); - _dist->set(target, relaxed); - if (!(*_mask)[target]) { - _mask->set(target, true); - nextProcess.push_back(target); - } - } - } - } - _process.swap(nextProcess); - return _process.empty(); - } - - /// \brief Executes the algorithm. - /// - /// Executes the algorithm. - /// - /// This method runs the Bellman-Ford algorithm from the root node(s) - /// in order to compute the shortest path to each node. - /// - /// The algorithm computes - /// - the shortest path tree (forest), - /// - the distance of each node from the root(s). - /// - /// \pre init() must be called and at least one root node should be - /// added with addSource() before using this function. - void start() { - int num = countNodes(*_gr) - 1; - for (int i = 0; i < num; ++i) { - if (processNextWeakRound()) break; - } - } - - /// \brief Executes the algorithm and checks the negative cycles. - /// - /// Executes the algorithm and checks the negative cycles. - /// - /// This method runs the Bellman-Ford algorithm from the root node(s) - /// in order to compute the shortest path to each node and also checks - /// if the digraph contains cycles with negative total length. - /// - /// The algorithm computes - /// - the shortest path tree (forest), - /// - the distance of each node from the root(s). - /// - /// \return \c false if there is a negative cycle in the digraph. - /// - /// \pre init() must be called and at least one root node should be - /// added with addSource() before using this function. - bool checkedStart() { - int num = countNodes(*_gr); - for (int i = 0; i < num; ++i) { - if (processNextWeakRound()) return true; - } - return _process.empty(); - } - - /// \brief Executes the algorithm with arc number limit. - /// - /// Executes the algorithm with arc number limit. - /// - /// This method runs the Bellman-Ford algorithm from the root node(s) - /// in order to compute the shortest path distance for each node - /// using only the paths consisting of at most \c num arcs. - /// - /// The algorithm computes - /// - the limited distance of each node from the root(s), - /// - the predecessor arc for each node. - /// - /// \warning The paths with limited arc number cannot be retrieved - /// easily with \ref path() or \ref predArc() functions. If you also - /// need the shortest paths and not only the distances, you should - /// store the \ref predMap() "predecessor map" after each iteration - /// and build the path manually. - /// - /// \pre init() must be called and at least one root node should be - /// added with addSource() before using this function. - void limitedStart(int num) { - for (int i = 0; i < num; ++i) { - if (processNextRound()) break; - } - } - - /// \brief Runs the algorithm from the given root node. - /// - /// This method runs the Bellman-Ford algorithm from the given root - /// node \c s in order to compute the shortest path to each node. - /// - /// The algorithm computes - /// - the shortest path tree (forest), - /// - the distance of each node from the root(s). - /// - /// \note bf.run(s) is just a shortcut of the following code. - /// \code - /// bf.init(); - /// bf.addSource(s); - /// bf.start(); - /// \endcode - void run(Node s) { - init(); - addSource(s); - start(); - } - - /// \brief Runs the algorithm from the given root node with arc - /// number limit. - /// - /// This method runs the Bellman-Ford algorithm from the given root - /// node \c s in order to compute the shortest path distance for each - /// node using only the paths consisting of at most \c num arcs. - /// - /// The algorithm computes - /// - the limited distance of each node from the root(s), - /// - the predecessor arc for each node. - /// - /// \warning The paths with limited arc number cannot be retrieved - /// easily with \ref path() or \ref predArc() functions. If you also - /// need the shortest paths and not only the distances, you should - /// store the \ref predMap() "predecessor map" after each iteration - /// and build the path manually. - /// - /// \note bf.run(s, num) is just a shortcut of the following code. - /// \code - /// bf.init(); - /// bf.addSource(s); - /// bf.limitedStart(num); - /// \endcode - void run(Node s, int num) { - init(); - addSource(s); - limitedStart(num); - } - - ///@} - - /// \brief LEMON iterator for getting the active nodes. - /// - /// This class provides a common style LEMON iterator that traverses - /// the active nodes of the Bellman-Ford algorithm after the last - /// phase. These nodes should be checked in the next phase to - /// find augmenting arcs outgoing from them. - class ActiveIt { - public: - - /// \brief Constructor. - /// - /// Constructor for getting the active nodes of the given BellmanFord - /// instance. - ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm) - { - _index = _algorithm->_process.size() - 1; - } - - /// \brief Invalid constructor. - /// - /// Invalid constructor. - ActiveIt(Invalid) : _algorithm(0), _index(-1) {} - - /// \brief Conversion to \c Node. - /// - /// Conversion to \c Node. - operator Node() const { - return _index >= 0 ? _algorithm->_process[_index] : INVALID; - } - - /// \brief Increment operator. - /// - /// Increment operator. - ActiveIt& operator++() { - --_index; - return *this; - } - - bool operator==(const ActiveIt& it) const { - return static_cast(*this) == static_cast(it); - } - bool operator!=(const ActiveIt& it) const { - return static_cast(*this) != static_cast(it); - } - bool operator<(const ActiveIt& it) const { - return static_cast(*this) < static_cast(it); - } - - private: - const BellmanFord* _algorithm; - int _index; - }; - - /// \name Query Functions - /// The result of the Bellman-Ford algorithm can be obtained using these - /// functions.\n - /// Either \ref run() or \ref init() should be called before using them. - - ///@{ - - /// \brief The shortest path to the given node. - /// - /// Gives back the shortest path to the given node from the root(s). - /// - /// \warning \c t should be reached from the root(s). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Path path(Node t) const - { - return Path(*_gr, *_pred, t); - } - - /// \brief The distance of the given node from the root(s). - /// - /// Returns the distance of the given node from the root(s). - /// - /// \warning If node \c v is not reached from the root(s), then - /// the return value of this function is undefined. - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Value dist(Node v) const { return (*_dist)[v]; } - - /// \brief Returns the 'previous arc' of the shortest path tree for - /// the given node. - /// - /// This function returns the 'previous arc' of the shortest path - /// tree for node \c v, i.e. it returns the last arc of a - /// shortest path from a root to \c v. It is \c INVALID if \c v - /// is not reached from the root(s) or if \c v is a root. - /// - /// The shortest path tree used here is equal to the shortest path - /// tree used in \ref predNode() and \predMap(). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Arc predArc(Node v) const { return (*_pred)[v]; } - - /// \brief Returns the 'previous node' of the shortest path tree for - /// the given node. - /// - /// This function returns the 'previous node' of the shortest path - /// tree for node \c v, i.e. it returns the last but one node of - /// a shortest path from a root to \c v. It is \c INVALID if \c v - /// is not reached from the root(s) or if \c v is a root. - /// - /// The shortest path tree used here is equal to the shortest path - /// tree used in \ref predArc() and \predMap(). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - Node predNode(Node v) const { - return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]); - } - - /// \brief Returns a const reference to the node map that stores the - /// distances of the nodes. - /// - /// Returns a const reference to the node map that stores the distances - /// of the nodes calculated by the algorithm. - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - const DistMap &distMap() const { return *_dist;} - - /// \brief Returns a const reference to the node map that stores the - /// predecessor arcs. - /// - /// Returns a const reference to the node map that stores the predecessor - /// arcs, which form the shortest path tree (forest). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - const PredMap &predMap() const { return *_pred; } - - /// \brief Checks if a node is reached from the root(s). - /// - /// Returns \c true if \c v is reached from the root(s). - /// - /// \pre Either \ref run() or \ref init() must be called before - /// using this function. - bool reached(Node v) const { - return (*_dist)[v] != OperationTraits::infinity(); - } - - /// \brief Gives back a negative cycle. - /// - /// This function gives back a directed cycle with negative total - /// length if the algorithm has already found one. - /// Otherwise it gives back an empty path. - lemon::Path negativeCycle() { - typename Digraph::template NodeMap state(*_gr, -1); - lemon::Path cycle; - for (int i = 0; i < int(_process.size()); ++i) { - if (state[_process[i]] != -1) continue; - for (Node v = _process[i]; (*_pred)[v] != INVALID; - v = _gr->source((*_pred)[v])) { - if (state[v] == i) { - cycle.addFront((*_pred)[v]); - for (Node u = _gr->source((*_pred)[v]); u != v; - u = _gr->source((*_pred)[u])) { - cycle.addFront((*_pred)[u]); - } - return cycle; - } - else if (state[v] >= 0) { - break; - } - state[v] = i; - } - } - return cycle; - } - - ///@} - }; - - /// \brief Default traits class of bellmanFord() function. - /// - /// Default traits class of bellmanFord() function. - /// \tparam GR The type of the digraph. - /// \tparam LEN The type of the length map. - template - struct BellmanFordWizardDefaultTraits { - /// The type of the digraph the algorithm runs on. - typedef GR Digraph; - - /// \brief The type of the map that stores the arc lengths. - /// - /// The type of the map that stores the arc lengths. - /// It must meet the \ref concepts::ReadMap "ReadMap" concept. - typedef LEN LengthMap; - - /// The type of the arc lengths. - typedef typename LEN::Value Value; - - /// \brief Operation traits for Bellman-Ford algorithm. - /// - /// It defines the used operations and the infinity value for the - /// given \c Value type. - /// \see BellmanFordDefaultOperationTraits - typedef BellmanFordDefaultOperationTraits OperationTraits; - - /// \brief The type of the map that stores the last - /// arcs of the shortest paths. - /// - /// The type of the map that stores the last arcs of the shortest paths. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap PredMap; - - /// \brief Instantiates a \c PredMap. - /// - /// This function instantiates a \ref PredMap. - /// \param g is the digraph to which we would like to define the - /// \ref PredMap. - static PredMap *createPredMap(const GR &g) { - return new PredMap(g); - } - - /// \brief The type of the map that stores the distances of the nodes. - /// - /// The type of the map that stores the distances of the nodes. - /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. - typedef typename GR::template NodeMap DistMap; - - /// \brief Instantiates a \c DistMap. - /// - /// This function instantiates a \ref DistMap. - /// \param g is the digraph to which we would like to define the - /// \ref DistMap. - static DistMap *createDistMap(const GR &g) { - return new DistMap(g); - } - - ///The type of the shortest paths. - - ///The type of the shortest paths. - ///It must meet the \ref concepts::Path "Path" concept. - typedef lemon::Path Path; - }; - - /// \brief Default traits class used by BellmanFordWizard. - /// - /// Default traits class used by BellmanFordWizard. - /// \tparam GR The type of the digraph. - /// \tparam LEN The type of the length map. - template - class BellmanFordWizardBase - : public BellmanFordWizardDefaultTraits { - - typedef BellmanFordWizardDefaultTraits Base; - protected: - // Type of the nodes in the digraph. - typedef typename Base::Digraph::Node Node; - - // Pointer to the underlying digraph. - void *_graph; - // Pointer to the length map - void *_length; - // Pointer to the map of predecessors arcs. - void *_pred; - // Pointer to the map of distances. - void *_dist; - //Pointer to the shortest path to the target node. - void *_path; - //Pointer to the distance of the target node. - void *_di; - - public: - /// Constructor. - - /// This constructor does not require parameters, it initiates - /// all of the attributes to default values \c 0. - BellmanFordWizardBase() : - _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {} - - /// Constructor. - - /// This constructor requires two parameters, - /// others are initiated to \c 0. - /// \param gr The digraph the algorithm runs on. - /// \param len The length map. - BellmanFordWizardBase(const GR& gr, - const LEN& len) : - _graph(reinterpret_cast(const_cast(&gr))), - _length(reinterpret_cast(const_cast(&len))), - _pred(0), _dist(0), _path(0), _di(0) {} - - }; - - /// \brief Auxiliary class for the function-type interface of the - /// \ref BellmanFord "Bellman-Ford" algorithm. - /// - /// This auxiliary class is created to implement the - /// \ref bellmanFord() "function-type interface" of the - /// \ref BellmanFord "Bellman-Ford" algorithm. - /// It does not have own \ref run() method, it uses the - /// functions and features of the plain \ref BellmanFord. - /// - /// This class should only be used through the \ref bellmanFord() - /// function, which makes it easier to use the algorithm. - template - class BellmanFordWizard : public TR { - typedef TR Base; - - typedef typename TR::Digraph Digraph; - - typedef typename Digraph::Node Node; - typedef typename Digraph::NodeIt NodeIt; - typedef typename Digraph::Arc Arc; - typedef typename Digraph::OutArcIt ArcIt; - - typedef typename TR::LengthMap LengthMap; - typedef typename LengthMap::Value Value; - typedef typename TR::PredMap PredMap; - typedef typename TR::DistMap DistMap; - typedef typename TR::Path Path; - - public: - /// Constructor. - BellmanFordWizard() : TR() {} - - /// \brief Constructor that requires parameters. - /// - /// Constructor that requires parameters. - /// These parameters will be the default values for the traits class. - /// \param gr The digraph the algorithm runs on. - /// \param len The length map. - BellmanFordWizard(const Digraph& gr, const LengthMap& len) - : TR(gr, len) {} - - /// \brief Copy constructor - BellmanFordWizard(const TR &b) : TR(b) {} - - ~BellmanFordWizard() {} - - /// \brief Runs the Bellman-Ford algorithm from the given source node. - /// - /// This method runs the Bellman-Ford algorithm from the given source - /// node in order to compute the shortest path to each node. - void run(Node s) { - BellmanFord - bf(*reinterpret_cast(Base::_graph), - *reinterpret_cast(Base::_length)); - if (Base::_pred) bf.predMap(*reinterpret_cast(Base::_pred)); - if (Base::_dist) bf.distMap(*reinterpret_cast(Base::_dist)); - bf.run(s); - } - - /// \brief Runs the Bellman-Ford algorithm to find the shortest path - /// between \c s and \c t. - /// - /// This method runs the Bellman-Ford algorithm from node \c s - /// in order to compute the shortest path to node \c t. - /// Actually, it computes the shortest path to each node, but using - /// this function you can retrieve the distance and the shortest path - /// for a single target node easier. - /// - /// \return \c true if \c t is reachable form \c s. - bool run(Node s, Node t) { - BellmanFord - bf(*reinterpret_cast(Base::_graph), - *reinterpret_cast(Base::_length)); - if (Base::_pred) bf.predMap(*reinterpret_cast(Base::_pred)); - if (Base::_dist) bf.distMap(*reinterpret_cast(Base::_dist)); - bf.run(s); - if (Base::_path) *reinterpret_cast(Base::_path) = bf.path(t); - if (Base::_di) *reinterpret_cast(Base::_di) = bf.dist(t); - return bf.reached(t); - } - - template - struct SetPredMapBase : public Base { - typedef T PredMap; - static PredMap *createPredMap(const Digraph &) { return 0; }; - SetPredMapBase(const TR &b) : TR(b) {} - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// the predecessor map. - /// - /// \ref named-templ-param "Named parameter" for setting - /// the map that stores the predecessor arcs of the nodes. - template - BellmanFordWizard > predMap(const T &t) { - Base::_pred=reinterpret_cast(const_cast(&t)); - return BellmanFordWizard >(*this); - } - - template - struct SetDistMapBase : public Base { - typedef T DistMap; - static DistMap *createDistMap(const Digraph &) { return 0; }; - SetDistMapBase(const TR &b) : TR(b) {} - }; - - /// \brief \ref named-templ-param "Named parameter" for setting - /// the distance map. - /// - /// \ref named-templ-param "Named parameter" for setting - /// the map that stores the distances of the nodes calculated - /// by the algorithm. - template - BellmanFordWizard > distMap(const T &t) { - Base::_dist=reinterpret_cast(const_cast(&t)); - return BellmanFordWizard >(*this); - } - - template - struct SetPathBase : public Base { - typedef T Path; - SetPathBase(const TR &b) : TR(b) {} - }; - - /// \brief \ref named-func-param "Named parameter" for getting - /// the shortest path to the target node. - /// - /// \ref named-func-param "Named parameter" for getting - /// the shortest path to the target node. - template - BellmanFordWizard > path(const T &t) - { - Base::_path=reinterpret_cast(const_cast(&t)); - return BellmanFordWizard >(*this); - } - - /// \brief \ref named-func-param "Named parameter" for getting - /// the distance of the target node. - /// - /// \ref named-func-param "Named parameter" for getting - /// the distance of the target node. - BellmanFordWizard dist(const Value &d) - { - Base::_di=reinterpret_cast(const_cast(&d)); - return *this; - } - - }; - - /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford" - /// algorithm. - /// - /// \ingroup shortest_path - /// Function type interface for the \ref BellmanFord "Bellman-Ford" - /// algorithm. - /// - /// This function also has several \ref named-templ-func-param - /// "named parameters", they are declared as the members of class - /// \ref BellmanFordWizard. - /// The following examples show how to use these parameters. - /// \code - /// // Compute shortest path from node s to each node - /// bellmanFord(g,length).predMap(preds).distMap(dists).run(s); - /// - /// // Compute shortest path from s to t - /// bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t); - /// \endcode - /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()" - /// to the end of the parameter list. - /// \sa BellmanFordWizard - /// \sa BellmanFord - template - BellmanFordWizard > - bellmanFord(const GR& digraph, - const LEN& length) - { - return BellmanFordWizard >(digraph, length); - } - -} //END OF NAMESPACE LEMON - -#endif - Index: lemon/bfs.h =================================================================== --- lemon/bfs.h (revision 717) +++ lemon/bfs.h (revision 503) @@ -48,5 +48,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a \c PredMap. @@ -63,6 +63,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. @@ -83,5 +82,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a \c ReachedMap. @@ -98,5 +97,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a \c DistMap. @@ -227,5 +226,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c PredMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap : public Bfs< Digraph, SetPredMapTraits > { @@ -247,5 +246,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c DistMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Bfs< Digraph, SetDistMapTraits > { @@ -267,5 +266,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ReachedMap type. - ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. template struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits > { @@ -287,5 +286,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ProcessedMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits > { @@ -415,6 +414,6 @@ ///The simplest way to execute the BFS algorithm is to use one of the ///member functions called \ref run(Node) "run()".\n - ///If you need better control on the execution, you have to call - ///\ref init() first, then you can add several source nodes with + ///If you need more control on the execution, first you have to call + ///\ref init(), then you can add several source nodes with ///\ref addSource(). Finally the actual path computation can be ///performed with one of the \ref start() functions. @@ -739,7 +738,7 @@ ///@{ - ///The shortest path to the given node. - - ///Returns the shortest path to the given node from the root(s). + ///The shortest path to a node. + + ///Returns the shortest path to a node. /// ///\warning \c t should be reached from the root(s). @@ -749,7 +748,7 @@ Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of the given node from the root(s). - - ///Returns the distance of the given node from the root(s). + ///The distance of a node from the root(s). + + ///Returns the distance of a node from the root(s). /// ///\warning If node \c v is not reached from the root(s), then @@ -760,7 +759,6 @@ int dist(Node v) const { return (*_dist)[v]; } - ///\brief Returns the 'previous arc' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous arc' of the shortest path tree for a node. + ///This function returns the 'previous arc' of the shortest path ///tree for the node \c v, i.e. it returns the last arc of a @@ -769,5 +767,5 @@ /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predNode() and \ref predMap(). + ///tree used in \ref predNode(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -775,14 +773,13 @@ Arc predArc(Node v) const { return (*_pred)[v];} - ///\brief Returns the 'previous node' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous node' of the shortest path tree for a node. + ///This function returns the 'previous node' of the shortest path ///tree for the node \c v, i.e. it returns the last but one node - ///of a shortest path from a root to \c v. It is \c INVALID + ///from a shortest path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predArc() and \ref predMap(). + ///tree used in \ref predArc(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -805,5 +802,5 @@ /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the shortest path tree (forest). + ///arcs, which form the shortest path tree. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -811,5 +808,5 @@ const PredMap &predMap() const { return *_pred;} - ///Checks if the given node is reached from the root(s). + ///Checks if a node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). @@ -837,5 +834,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -852,5 +849,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; @@ -872,5 +869,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a ReachedMap. @@ -887,5 +884,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -902,5 +899,5 @@ ///The type of the shortest paths. - ///It must conform to the \ref concepts::Path "Path" concept. + ///It must meet the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; @@ -908,6 +905,10 @@ /// Default traits class used by BfsWizard - /// Default traits class used by BfsWizard. - /// \tparam GR The type of the digraph. + /// To make it easier to use Bfs algorithm + /// we have created a wizard class. + /// This \ref BfsWizard class needs default traits, + /// as well as the \ref Bfs class. + /// The \ref BfsWizardBase is a class to be the default traits of the + /// \ref BfsWizard class. template class BfsWizardBase : public BfsWizardDefaultTraits @@ -937,5 +938,5 @@ /// Constructor. - /// This constructor does not require parameters, it initiates + /// This constructor does not require parameters, therefore it initiates /// all of the attributes to \c 0. BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), @@ -967,4 +968,5 @@ typedef TR Base; + ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; @@ -974,8 +976,14 @@ typedef typename Digraph::OutArcIt OutArcIt; + ///\brief The type of the map that stores the predecessor + ///arcs of the shortest paths. typedef typename TR::PredMap PredMap; + ///\brief The type of the map that stores the distances of the nodes. typedef typename TR::DistMap DistMap; + ///\brief The type of the map that indicates which nodes are reached. typedef typename TR::ReachedMap ReachedMap; + ///\brief The type of the map that indicates which nodes are processed. typedef typename TR::ProcessedMap ProcessedMap; + ///The type of the shortest paths typedef typename TR::Path Path; @@ -1060,10 +1068,9 @@ SetPredMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the predecessor map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the predecessor arcs of the nodes. + ///\brief \ref named-func-param "Named parameter" + ///for setting PredMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting PredMap object. template BfsWizard > predMap(const T &t) @@ -1079,10 +1086,9 @@ SetReachedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the reached map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are reached. + ///\brief \ref named-func-param "Named parameter" + ///for setting ReachedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ReachedMap object. template BfsWizard > reachedMap(const T &t) @@ -1098,11 +1104,9 @@ SetDistMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the distance map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the distances of the nodes calculated - ///by the algorithm. + ///\brief \ref named-func-param "Named parameter" + ///for setting DistMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting DistMap object. template BfsWizard > distMap(const T &t) @@ -1118,10 +1122,9 @@ SetProcessedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-func-param "Named parameter" for setting - ///the processed map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are processed. + ///\brief \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. template BfsWizard > processedMap(const T &t) @@ -1262,5 +1265,5 @@ /// /// The type of the map that indicates which nodes are reached. - /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; @@ -1423,6 +1426,6 @@ /// The simplest way to execute the BFS algorithm is to use one of the /// member functions called \ref run(Node) "run()".\n - /// If you need better control on the execution, you have to call - /// \ref init() first, then you can add several source nodes with + /// If you need more control on the execution, first you have to call + /// \ref init(), then you can add several source nodes with /// \ref addSource(). Finally the actual path computation can be /// performed with one of the \ref start() functions. @@ -1733,5 +1736,5 @@ ///@{ - /// \brief Checks if the given node is reached from the root(s). + /// \brief Checks if a node is reached from the root(s). /// /// Returns \c true if \c v is reached from the root(s). Index: lemon/bin_heap.h =================================================================== --- lemon/bin_heap.h (revision 711) +++ lemon/bin_heap.h (revision 584) @@ -20,7 +20,7 @@ #define LEMON_BIN_HEAP_H -///\ingroup heaps +///\ingroup auxdat ///\file -///\brief Binary heap implementation. +///\brief Binary Heap implementation. #include @@ -30,39 +30,43 @@ namespace lemon { - /// \ingroup heaps + ///\ingroup auxdat /// - /// \brief Binary heap data structure. + ///\brief A Binary Heap implementation. /// - /// This class implements the \e binary \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". + ///This class implements the \e binary \e heap data structure. + /// + ///A \e heap is a data structure for storing items with specified values + ///called \e priorities in such a way that finding the item with minimum + ///priority is efficient. \c Comp specifies the ordering of the priorities. + ///In a heap one can change the priority of an item, add or erase an + ///item, etc. /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. -#ifdef DOXYGEN - template -#else - template > -#endif + ///\tparam PR Type of the priority of the items. + ///\tparam IM A read and writable item map with int values, used internally + ///to handle the cross references. + ///\tparam Comp A functor class for the ordering of the priorities. + ///The default is \c std::less. + /// + ///\sa FibHeap + ///\sa Dijkstra + template > class BinHeap { + public: - - /// Type of the item-int map. + ///\e typedef IM ItemIntMap; - /// Type of the priorities. + ///\e typedef PR Prio; - /// Type of the items stored in the heap. + ///\e typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. + ///\e typedef std::pair Pair; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the + ///\e + typedef Comp Compare; + + /// \brief Type to represent the items states. + /// + /// Each Item element have a state associated to it. It may be "in heap", + /// "pre heap" or "post heap". The latter two are indifferent from the /// heap's point of view, but may be useful to the user. /// @@ -81,41 +85,40 @@ public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. + /// \brief The constructor. + /// + /// The constructor. + /// \param map should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// must be \c PRE_HEAP (-1) for every item. explicit BinHeap(ItemIntMap &map) : _iim(map) {} - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. + /// \brief The constructor. + /// + /// The constructor. + /// \param map should be given to the constructor, since it is used + /// internally to handle the cross references. The value of the map + /// should be PRE_HEAP (-1) for each element. + /// + /// \param comp The comparator function object. BinHeap(ItemIntMap &map, const Compare &comp) : _iim(map), _comp(comp) {} - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. + /// The number of items stored in the heap. + /// + /// \brief Returns the number of items stored in the heap. int size() const { return _data.size(); } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap stores no items. + /// + /// Returns \c true if and only if the heap stores no items. bool empty() const { return _data.empty(); } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. + /// \brief Make empty this heap. + /// + /// Make empty this heap. It does not change the cross reference map. + /// If you want to reuse what is not surely empty you should first clear + /// the heap and after that you should set the cross reference map for + /// each item to \c PRE_HEAP. void clear() { _data.clear(); @@ -125,10 +128,10 @@ static int parent(int i) { return (i-1)/2; } - static int secondChild(int i) { return 2*i+2; } + static int second_child(int i) { return 2*i+2; } bool less(const Pair &p1, const Pair &p2) const { return _comp(p1.second, p2.second); } - int bubbleUp(int hole, Pair p) { + int bubble_up(int hole, Pair p) { int par = parent(hole); while( hole>0 && less(p,_data[par]) ) { @@ -141,6 +144,6 @@ } - int bubbleDown(int hole, Pair p, int length) { - int child = secondChild(hole); + int bubble_down(int hole, Pair p, int length) { + int child = second_child(hole); while(child < length) { if( less(_data[child-1], _data[child]) ) { @@ -151,5 +154,5 @@ move(_data[child], hole); hole = child; - child = secondChild(hole); + child = second_child(hole); } child--; @@ -169,45 +172,42 @@ public: - /// \brief Insert a pair of item and priority into the heap. /// - /// This function inserts \c p.first to the heap with priority - /// \c p.second. + /// Adds \c p.first to the heap with priority \c p.second. /// \param p The pair to insert. - /// \pre \c p.first must not be stored in the heap. void push(const Pair &p) { int n = _data.size(); _data.resize(n+1); - bubbleUp(n, p); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. + bubble_up(n, p); + } + + /// \brief Insert an item into the heap with the given heap. + /// + /// Adds \c i to the heap with priority \c p. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. void push(const Item &i, const Prio &p) { push(Pair(i,p)); } - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the item with minimum priority relative to \c Compare. + /// + /// This method returns the item with minimum priority relative to \c + /// Compare. + /// \pre The heap must be nonempty. Item top() const { return _data[0].first; } - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. + /// \brief Returns the minimum priority relative to \c Compare. + /// + /// It returns the minimum priority relative to \c Compare. + /// \pre The heap must be nonempty. Prio prio() const { return _data[0].second; } - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Deletes the item with minimum priority relative to \c Compare. + /// + /// This method deletes the item with minimum priority relative to \c + /// Compare from the heap. /// \pre The heap must be non-empty. void pop() { @@ -215,15 +215,14 @@ _iim.set(_data[0].first, POST_HEAP); if (n > 0) { - bubbleDown(0, _data[n], n); + bubble_down(0, _data[n], n); } _data.pop_back(); } - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. + /// \brief Deletes \c i from the heap. + /// + /// This method deletes item \c i from the heap. + /// \param i The item to erase. + /// \pre The item should be in the heap. void erase(const Item &i) { int h = _iim[i]; @@ -231,6 +230,6 @@ _iim.set(_data[h].first, POST_HEAP); if( h < n ) { - if ( bubbleUp(h, _data[n]) == h) { - bubbleDown(h, _data[n], n); + if ( bubble_up(h, _data[n]) == h) { + bubble_down(h, _data[n], n); } } @@ -238,9 +237,10 @@ } - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. + + /// \brief Returns the priority of \c i. + /// + /// This function returns the priority of item \c i. + /// \param i The item. + /// \pre \c i must be in the heap. Prio operator[](const Item &i) const { int idx = _iim[i]; @@ -248,10 +248,9 @@ } - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. + /// \brief \c i gets to the heap with priority \c p independently + /// if \c i was already there. + /// + /// This method calls \ref push(\c i, \c p) if \c i is not stored + /// in the heap and sets the priority of \c i to \c p otherwise. /// \param i The item. /// \param p The priority. @@ -262,40 +261,42 @@ } else if( _comp(p, _data[idx].second) ) { - bubbleUp(idx, Pair(i,p)); + bubble_up(idx, Pair(i,p)); } else { - bubbleDown(idx, Pair(i,p), _data.size()); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. + bubble_down(idx, Pair(i,p), _data.size()); + } + } + + /// \brief Decreases the priority of \c i to \c p. + /// + /// This method decreases the priority of item \c i to \c p. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. + /// \pre \c i must be stored in the heap with priority at least \c + /// p relative to \c Compare. void decrease(const Item &i, const Prio &p) { int idx = _iim[i]; - bubbleUp(idx, Pair(i,p)); - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. + bubble_up(idx, Pair(i,p)); + } + + /// \brief Increases the priority of \c i to \c p. + /// + /// This method sets the priority of item \c i to \c p. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. + /// \pre \c i must be stored in the heap with priority at most \c + /// p relative to \c Compare. void increase(const Item &i, const Prio &p) { int idx = _iim[i]; - bubbleDown(idx, Pair(i,p), _data.size()); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. + bubble_down(idx, Pair(i,p), _data.size()); + } + + /// \brief Returns if \c item is in, has already been in, or has + /// never been in the heap. + /// + /// This method returns PRE_HEAP if \c item has never been in the + /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP + /// otherwise. In the latter case it is possible that \c item will + /// get back to the heap again. /// \param i The item. State state(const Item &i) const { @@ -306,9 +307,9 @@ } - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + /// \brief Sets the state of the \c item in the heap. + /// + /// Sets the state of the \c item in the heap. It can be used to + /// manually clear the heap when it is important to achive the + /// better time complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. @@ -327,11 +328,10 @@ } - /// \brief Replace an item in the heap. - /// - /// This function replaces item \c i with item \c j. - /// Item \c i must be in the heap, while \c j must be out of the heap. - /// After calling this method, item \c i will be out of the - /// heap and \c j will be in the heap with the same prioriority - /// as item \c i had before. + /// \brief Replaces an item in the heap. + /// + /// The \c i item is replaced with \c j item. The \c i item should + /// be in the heap, while the \c j should be out of the heap. The + /// \c i item will out of the heap and \c j will be in the heap + /// with the same prioriority as prevoiusly the \c i item. void replace(const Item& i, const Item& j) { int idx = _iim[i]; Index: mon/binom_heap.h =================================================================== --- lemon/binom_heap.h (revision 707) +++ (revision ) @@ -1,445 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BINOM_HEAP_H -#define LEMON_BINOM_HEAP_H - -///\file -///\ingroup heaps -///\brief Binomial Heap implementation. - -#include -#include -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - ///\brief Binomial heap data structure. - /// - /// This class implements the \e binomial \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The methods \ref increase() and \ref erase() are not efficient - /// in a binomial heap. In case of many calls of these operations, - /// it is better to use other heap structure, e.g. \ref BinHeap - /// "binary heap". - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. -#ifdef DOXYGEN - template -#else - template > -#endif - class BinomHeap { - public: - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - class Store; - - std::vector _data; - int _min, _head; - ItemIntMap &_iim; - Compare _comp; - int _num_items; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit BinomHeap(ItemIntMap &map) - : _min(0), _head(-1), _iim(map), _num_items(0) {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - BinomHeap(ItemIntMap &map, const Compare &comp) - : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _num_items; } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _num_items==0; } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { - _data.clear(); _min=0; _num_items=0; _head=-1; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. - /// \param item The item. - /// \param value The priority. - void set (const Item& item, const Prio& value) { - int i=_iim[item]; - if ( i >= 0 && _data[i].in ) { - if ( _comp(value, _data[i].prio) ) decrease(item, value); - if ( _comp(_data[i].prio, value) ) increase(item, value); - } else push(item, value); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param item The item to insert. - /// \param value The priority of the item. - /// \pre \e item must not be stored in the heap. - void push (const Item& item, const Prio& value) { - int i=_iim[item]; - if ( i<0 ) { - int s=_data.size(); - _iim.set( item,s ); - Store st; - st.name=item; - st.prio=value; - _data.push_back(st); - i=s; - } - else { - _data[i].parent=_data[i].right_neighbor=_data[i].child=-1; - _data[i].degree=0; - _data[i].in=true; - _data[i].prio=value; - } - - if( 0==_num_items ) { - _head=i; - _min=i; - } else { - merge(i); - if( _comp(_data[i].prio, _data[_min].prio) ) _min=i; - } - ++_num_items; - } - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. - Item top() const { return _data[_min].name; } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { return _data[_min].prio; } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param item The item. - /// \pre \e item must be in the heap. - const Prio& operator[](const Item& item) const { - return _data[_iim[item]].prio; - } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. - /// \pre The heap must be non-empty. - void pop() { - _data[_min].in=false; - - int head_child=-1; - if ( _data[_min].child!=-1 ) { - int child=_data[_min].child; - int neighb; - while( child!=-1 ) { - neighb=_data[child].right_neighbor; - _data[child].parent=-1; - _data[child].right_neighbor=head_child; - head_child=child; - child=neighb; - } - } - - if ( _data[_head].right_neighbor==-1 ) { - // there was only one root - _head=head_child; - } - else { - // there were more roots - if( _head!=_min ) { unlace(_min); } - else { _head=_data[_head].right_neighbor; } - merge(head_child); - } - _min=findMin(); - --_num_items; - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param item The item to delete. - /// \pre \e item must be in the heap. - void erase (const Item& item) { - int i=_iim[item]; - if ( i >= 0 && _data[i].in ) { - decrease( item, _data[_min].prio-1 ); - pop(); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. - /// \param item The item. - /// \param value The priority. - /// \pre \e item must be stored in the heap with priority at least \e value. - void decrease (Item item, const Prio& value) { - int i=_iim[item]; - int p=_data[i].parent; - _data[i].prio=value; - - while( p!=-1 && _comp(value, _data[p].prio) ) { - _data[i].name=_data[p].name; - _data[i].prio=_data[p].prio; - _data[p].name=item; - _data[p].prio=value; - _iim[_data[i].name]=i; - i=p; - p=_data[p].parent; - } - _iim[item]=i; - if ( _comp(value, _data[_min].prio) ) _min=i; - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param item The item. - /// \param value The priority. - /// \pre \e item must be stored in the heap with priority at most \e value. - void increase (Item item, const Prio& value) { - erase(item); - push(item, value); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param item The item. - State state(const Item &item) const { - int i=_iim[item]; - if( i>=0 ) { - if ( _data[i].in ) i=0; - else i=-2; - } - return State(i); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) { - erase(i); - } - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - private: - - // Find the minimum of the roots - int findMin() { - if( _head!=-1 ) { - int min_loc=_head, min_val=_data[_head].prio; - for( int x=_data[_head].right_neighbor; x!=-1; - x=_data[x].right_neighbor ) { - if( _comp( _data[x].prio,min_val ) ) { - min_val=_data[x].prio; - min_loc=x; - } - } - return min_loc; - } - else return -1; - } - - // Merge the heap with another heap starting at the given position - void merge(int a) { - if( _head==-1 || a==-1 ) return; - if( _data[a].right_neighbor==-1 && - _data[a].degree<=_data[_head].degree ) { - _data[a].right_neighbor=_head; - _head=a; - } else { - interleave(a); - } - if( _data[_head].right_neighbor==-1 ) return; - - int x=_head; - int x_prev=-1, x_next=_data[x].right_neighbor; - while( x_next!=-1 ) { - if( _data[x].degree!=_data[x_next].degree || - ( _data[x_next].right_neighbor!=-1 && - _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) { - x_prev=x; - x=x_next; - } - else { - if( _comp(_data[x_next].prio,_data[x].prio) ) { - if( x_prev==-1 ) { - _head=x_next; - } else { - _data[x_prev].right_neighbor=x_next; - } - fuse(x,x_next); - x=x_next; - } - else { - _data[x].right_neighbor=_data[x_next].right_neighbor; - fuse(x_next,x); - } - } - x_next=_data[x].right_neighbor; - } - } - - // Interleave the elements of the given list into the list of the roots - void interleave(int a) { - int p=_head, q=a; - int curr=_data.size(); - _data.push_back(Store()); - - while( p!=-1 || q!=-1 ) { - if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) { - _data[curr].right_neighbor=p; - curr=p; - p=_data[p].right_neighbor; - } - else { - _data[curr].right_neighbor=q; - curr=q; - q=_data[q].right_neighbor; - } - } - - _head=_data.back().right_neighbor; - _data.pop_back(); - } - - // Lace node a under node b - void fuse(int a, int b) { - _data[a].parent=b; - _data[a].right_neighbor=_data[b].child; - _data[b].child=a; - - ++_data[b].degree; - } - - // Unlace node a (if it has siblings) - void unlace(int a) { - int neighb=_data[a].right_neighbor; - int other=_head; - - while( _data[other].right_neighbor!=a ) - other=_data[other].right_neighbor; - _data[other].right_neighbor=neighb; - } - - private: - - class Store { - friend class BinomHeap; - - Item name; - int parent; - int right_neighbor; - int child; - int degree; - bool in; - Prio prio; - - Store() : parent(-1), right_neighbor(-1), child(-1), degree(0), - in(true) {} - }; - }; - -} //namespace lemon - -#endif //LEMON_BINOM_HEAP_H - Index: lemon/bits/edge_set_extender.h =================================================================== --- lemon/bits/edge_set_extender.h (revision 685) +++ lemon/bits/edge_set_extender.h (revision 617) @@ -538,5 +538,5 @@ public: - explicit ArcMap(const Graph& _g) + ArcMap(const Graph& _g) : Parent(_g) {} ArcMap(const Graph& _g, const _Value& _v) @@ -562,5 +562,5 @@ public: - explicit EdgeMap(const Graph& _g) + EdgeMap(const Graph& _g) : Parent(_g) {} Index: lemon/bits/graph_extender.h =================================================================== --- lemon/bits/graph_extender.h (revision 685) +++ lemon/bits/graph_extender.h (revision 617) @@ -605,5 +605,5 @@ public: - explicit NodeMap(const Graph& graph) + NodeMap(const Graph& graph) : Parent(graph) {} NodeMap(const Graph& graph, const _Value& value) @@ -629,5 +629,5 @@ public: - explicit ArcMap(const Graph& graph) + ArcMap(const Graph& graph) : Parent(graph) {} ArcMap(const Graph& graph, const _Value& value) @@ -653,5 +653,5 @@ public: - explicit EdgeMap(const Graph& graph) + EdgeMap(const Graph& graph) : Parent(graph) {} Index: lemon/bits/map_extender.h =================================================================== --- lemon/bits/map_extender.h (revision 718) +++ lemon/bits/map_extender.h (revision 617) @@ -50,6 +50,4 @@ typedef typename Parent::ConstReference ConstReference; - typedef typename Parent::ReferenceMapTag ReferenceMapTag; - class MapIt; class ConstMapIt; @@ -194,6 +192,4 @@ typedef typename Parent::ConstReference ConstReference; - typedef typename Parent::ReferenceMapTag ReferenceMapTag; - class MapIt; class ConstMapIt; Index: mon/bucket_heap.h =================================================================== --- lemon/bucket_heap.h (revision 711) +++ (revision ) @@ -1,594 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_BUCKET_HEAP_H -#define LEMON_BUCKET_HEAP_H - -///\ingroup heaps -///\file -///\brief Bucket heap implementation. - -#include -#include -#include - -namespace lemon { - - namespace _bucket_heap_bits { - - template - struct DirectionTraits { - static bool less(int left, int right) { - return left < right; - } - static void increase(int& value) { - ++value; - } - }; - - template <> - struct DirectionTraits { - static bool less(int left, int right) { - return left > right; - } - static void increase(int& value) { - --value; - } - }; - - } - - /// \ingroup heaps - /// - /// \brief Bucket heap data structure. - /// - /// This class implements the \e bucket \e heap data structure. - /// It practically conforms to the \ref concepts::Heap "heap concept", - /// but it has some limitations. - /// - /// The bucket heap is a very simple structure. It can store only - /// \c int priorities and it maintains a list of items for each priority - /// in the range [0..C). So it should only be used when the - /// priorities are small. It is not intended to use as a Dijkstra heap. - /// - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. - /// The default is \e min-heap. If this parameter is set to \c false, - /// then the comparison is reversed, so the top(), prio() and pop() - /// functions deal with the item having maximum priority instead of the - /// minimum. - /// - /// \sa SimpleBucketHeap - template - class BucketHeap { - - public: - - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef int Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; - - private: - - typedef _bucket_heap_bits::DirectionTraits Direction; - - public: - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _data.size(); } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _data.empty(); } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { - _data.clear(); _first.clear(); _minimum = 0; - } - - private: - - void relocateLast(int idx) { - if (idx + 1 < int(_data.size())) { - _data[idx] = _data.back(); - if (_data[idx].prev != -1) { - _data[_data[idx].prev].next = idx; - } else { - _first[_data[idx].value] = idx; - } - if (_data[idx].next != -1) { - _data[_data[idx].next].prev = idx; - } - _iim[_data[idx].item] = idx; - } - _data.pop_back(); - } - - void unlace(int idx) { - if (_data[idx].prev != -1) { - _data[_data[idx].prev].next = _data[idx].next; - } else { - _first[_data[idx].value] = _data[idx].next; - } - if (_data[idx].next != -1) { - _data[_data[idx].next].prev = _data[idx].prev; - } - } - - void lace(int idx) { - if (int(_first.size()) <= _data[idx].value) { - _first.resize(_data[idx].value + 1, -1); - } - _data[idx].next = _first[_data[idx].value]; - if (_data[idx].next != -1) { - _data[_data[idx].next].prev = idx; - } - _first[_data[idx].value] = idx; - _data[idx].prev = -1; - } - - public: - - /// \brief Insert a pair of item and priority into the heap. - /// - /// This function inserts \c p.first to the heap with priority - /// \c p.second. - /// \param p The pair to insert. - /// \pre \c p.first must not be stored in the heap. - void push(const Pair& p) { - push(p.first, p.second); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param i The item to insert. - /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. - void push(const Item &i, const Prio &p) { - int idx = _data.size(); - _iim[i] = idx; - _data.push_back(BucketItem(i, p)); - lace(idx); - if (Direction::less(p, _minimum)) { - _minimum = p; - } - } - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. - Item top() const { - while (_first[_minimum] == -1) { - Direction::increase(_minimum); - } - return _data[_first[_minimum]].item; - } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { - while (_first[_minimum] == -1) { - Direction::increase(_minimum); - } - return _minimum; - } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. - /// \pre The heap must be non-empty. - void pop() { - while (_first[_minimum] == -1) { - Direction::increase(_minimum); - } - int idx = _first[_minimum]; - _iim[_data[idx].item] = -2; - unlace(idx); - relocateLast(idx); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. - void erase(const Item &i) { - int idx = _iim[i]; - _iim[_data[idx].item] = -2; - unlace(idx); - relocateLast(idx); - } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. - Prio operator[](const Item &i) const { - int idx = _iim[i]; - return _data[idx].value; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. - /// \param i The item. - /// \param p The priority. - void set(const Item &i, const Prio &p) { - int idx = _iim[i]; - if (idx < 0) { - push(i, p); - } else if (Direction::less(p, _data[idx].value)) { - decrease(i, p); - } else { - increase(i, p); - } - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. - /// \param i The item. - /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. - void decrease(const Item &i, const Prio &p) { - int idx = _iim[i]; - unlace(idx); - _data[idx].value = p; - if (Direction::less(p, _minimum)) { - _minimum = p; - } - lace(idx); - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param i The item. - /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. - void increase(const Item &i, const Prio &p) { - int idx = _iim[i]; - unlace(idx); - _data[idx].value = p; - lace(idx); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param i The item. - State state(const Item &i) const { - int idx = _iim[i]; - if (idx >= 0) idx = 0; - return State(idx); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) { - erase(i); - } - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - private: - - struct BucketItem { - BucketItem(const Item& _item, int _value) - : item(_item), value(_value) {} - - Item item; - int value; - - int prev, next; - }; - - ItemIntMap& _iim; - std::vector _first; - std::vector _data; - mutable int _minimum; - - }; // class BucketHeap - - /// \ingroup heaps - /// - /// \brief Simplified bucket heap data structure. - /// - /// This class implements a simplified \e bucket \e heap data - /// structure. It does not provide some functionality, but it is - /// faster and simpler than BucketHeap. The main difference is - /// that BucketHeap stores a doubly-linked list for each key while - /// this class stores only simply-linked lists. It supports erasing - /// only for the item having minimum priority and it does not support - /// key increasing and decreasing. - /// - /// Note that this implementation does not conform to the - /// \ref concepts::Heap "heap concept" due to the lack of some - /// functionality. - /// - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. - /// The default is \e min-heap. If this parameter is set to \c false, - /// then the comparison is reversed, so the top(), prio() and pop() - /// functions deal with the item having maximum priority instead of the - /// minimum. - /// - /// \sa BucketHeap - template - class SimpleBucketHeap { - - public: - - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef int Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; - - private: - - typedef _bucket_heap_bits::DirectionTraits Direction; - - public: - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit SimpleBucketHeap(ItemIntMap &map) - : _iim(map), _free(-1), _num(0), _minimum(0) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _num; } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _num == 0; } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { - _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; - } - - /// \brief Insert a pair of item and priority into the heap. - /// - /// This function inserts \c p.first to the heap with priority - /// \c p.second. - /// \param p The pair to insert. - /// \pre \c p.first must not be stored in the heap. - void push(const Pair& p) { - push(p.first, p.second); - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param i The item to insert. - /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. - void push(const Item &i, const Prio &p) { - int idx; - if (_free == -1) { - idx = _data.size(); - _data.push_back(BucketItem(i)); - } else { - idx = _free; - _free = _data[idx].next; - _data[idx].item = i; - } - _iim[i] = idx; - if (p >= int(_first.size())) _first.resize(p + 1, -1); - _data[idx].next = _first[p]; - _first[p] = idx; - if (Direction::less(p, _minimum)) { - _minimum = p; - } - ++_num; - } - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. - Item top() const { - while (_first[_minimum] == -1) { - Direction::increase(_minimum); - } - return _data[_first[_minimum]].item; - } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { - while (_first[_minimum] == -1) { - Direction::increase(_minimum); - } - return _minimum; - } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. - /// \pre The heap must be non-empty. - void pop() { - while (_first[_minimum] == -1) { - Direction::increase(_minimum); - } - int idx = _first[_minimum]; - _iim[_data[idx].item] = -2; - _first[_minimum] = _data[idx].next; - _data[idx].next = _free; - _free = idx; - --_num; - } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. - /// \warning This operator is not a constant time function because - /// it scans the whole data structure to find the proper value. - Prio operator[](const Item &i) const { - for (int k = 0; k < int(_first.size()); ++k) { - int idx = _first[k]; - while (idx != -1) { - if (_data[idx].item == i) { - return k; - } - idx = _data[idx].next; - } - } - return -1; - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param i The item. - State state(const Item &i) const { - int idx = _iim[i]; - if (idx >= 0) idx = 0; - return State(idx); - } - - private: - - struct BucketItem { - BucketItem(const Item& _item) - : item(_item) {} - - Item item; - int next; - }; - - ItemIntMap& _iim; - std::vector _first; - std::vector _data; - int _free, _num; - mutable int _minimum; - - }; // class SimpleBucketHeap - -} - -#endif Index: lemon/cbc.cc =================================================================== --- lemon/cbc.cc (revision 746) +++ lemon/cbc.cc (revision 576) @@ -95,16 +95,4 @@ } - int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { - std::vector indexes; - std::vector values; - - for(ExprIterator it = b; it != e; ++it) { - indexes.push_back(it->first); - values.push_back(it->second); - } - - _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u); - return _prob->numberRows() - 1; - } void CbcMip::_eraseCol(int i) { Index: lemon/cbc.h =================================================================== --- lemon/cbc.h (revision 746) +++ lemon/cbc.h (revision 576) @@ -63,5 +63,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: lemon/circulation.h =================================================================== --- lemon/circulation.h (revision 715) +++ lemon/circulation.h (revision 688) @@ -73,9 +73,5 @@ /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept. -#ifdef DOXYGEN - typedef GR::ArcMap FlowMap; -#else typedef typename Digraph::template ArcMap FlowMap; -#endif /// \brief Instantiates a FlowMap. @@ -92,10 +88,7 @@ /// The elevator type used by the algorithm. /// - /// \sa Elevator, LinkedElevator -#ifdef DOXYGEN - typedef lemon::Elevator Elevator; -#else + /// \sa Elevator + /// \sa LinkedElevator typedef lemon::Elevator Elevator; -#endif /// \brief Instantiates an Elevator. @@ -458,8 +451,7 @@ } - /// \brief Sets the tolerance used by the algorithm. - /// - /// Sets the tolerance object used by the algorithm. - /// \return (*this) + /// \brief Sets the tolerance used by algorithm. + /// + /// Sets the tolerance used by algorithm. Circulation& tolerance(const Tolerance& tolerance) { _tol = tolerance; @@ -469,6 +461,5 @@ /// \brief Returns a const reference to the tolerance. /// - /// Returns a const reference to the tolerance object used by - /// the algorithm. + /// Returns a const reference to the tolerance. const Tolerance& tolerance() const { return _tol; @@ -477,6 +468,6 @@ /// \name Execution Control /// The simplest way to execute the algorithm is to call \ref run().\n - /// If you need better control on the initial solution or the execution, - /// you have to call one of the \ref init() functions first, then + /// If you need more control on the initial solution or the execution, + /// first you have to call one of the \ref init() functions, then /// the \ref start() function. Index: lemon/clp.cc =================================================================== --- lemon/clp.cc (revision 746) +++ lemon/clp.cc (revision 576) @@ -79,17 +79,4 @@ } - int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) { - std::vector indexes; - std::vector values; - - for(ExprIterator it = b; it != e; ++it) { - indexes.push_back(it->first); - values.push_back(it->second); - } - - _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u); - return _prob->numberRows() - 1; - } - void ClpLp::_eraseCol(int c) { Index: lemon/clp.h =================================================================== --- lemon/clp.h (revision 746) +++ lemon/clp.h (revision 576) @@ -76,5 +76,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: lemon/concepts/digraph.h =================================================================== --- lemon/concepts/digraph.h (revision 734) +++ lemon/concepts/digraph.h (revision 580) @@ -36,38 +36,44 @@ /// \brief Class describing the concept of directed graphs. /// - /// This class describes the common interface of all directed - /// graphs (digraphs). + /// This class describes the \ref concept "concept" of the + /// immutable directed digraphs. /// - /// Like all concept classes, it only provides an interface - /// without any sensible implementation. So any general algorithm for - /// directed graphs should compile with this class, but it will not - /// run properly, of course. - /// An actual digraph implementation like \ref ListDigraph or - /// \ref SmartDigraph may have additional functionality. + /// Note that actual digraph implementation like @ref ListDigraph or + /// @ref SmartDigraph may have several additional functionality. /// - /// \sa Graph + /// \sa concept class Digraph { private: - /// Diraphs are \e not copy constructible. Use DigraphCopy instead. - Digraph(const Digraph &) {} - /// \brief Assignment of a digraph to another one is \e not allowed. - /// Use DigraphCopy instead. + ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. + + ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. + /// + Digraph(const Digraph &) {}; + ///\brief Assignment of \ref Digraph "Digraph"s to another ones are + ///\e not allowed. Use DigraphCopy() instead. + + ///Assignment of \ref Digraph "Digraph"s to another ones are + ///\e not allowed. Use DigraphCopy() instead. + void operator=(const Digraph &) {} - public: - /// Default constructor. + ///\e + + /// Defalult constructor. + + /// Defalult constructor. + /// Digraph() { } - - /// The node type of the digraph + /// Class for identifying a node of the digraph /// This class identifies a node of the digraph. It also serves /// as a base class of the node iterators, - /// thus they convert to this type. + /// thus they will convert to this type. class Node { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Node() { } /// Copy constructor. @@ -77,37 +83,38 @@ Node(const Node&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. + /// Invalid constructor \& conversion. + + /// This constructor initializes the iterator to be invalid. /// \sa Invalid for more details. Node(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Node) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Node n) + /// bool operator!=(Node) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the nodes; this order has nothing to do with the iteration - /// ordering of the nodes. + /// To allow the use of digraph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Node) const { return false; } - }; - - /// Iterator class for the nodes. - - /// This iterator goes through each node of the digraph. + + }; + + /// This iterator goes through each node. + + /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number - /// of nodes in a digraph \c g of type \c %Digraph like this: + /// of nodes in digraph \c g of type \c Digraph like this: ///\code /// int count=0; @@ -118,6 +125,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. NodeIt() { } /// Copy constructor. @@ -126,18 +133,20 @@ /// NodeIt(const NodeIt& n) : Node(n) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. + /// Invalid constructor \& conversion. + + /// Initialize the iterator to be invalid. /// \sa Invalid for more details. NodeIt(Invalid) { } /// Sets the iterator to the first node. - /// Sets the iterator to the first node of the given digraph. - /// - explicit NodeIt(const Digraph&) { } - /// Sets the iterator to the given node. - - /// Sets the iterator to the given node of the given digraph. - /// + /// Sets the iterator to the first node of \c g. + /// + NodeIt(const Digraph&) { } + /// Node -> NodeIt conversion. + + /// Sets the iterator to the node of \c the digraph pointed by + /// the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. NodeIt(const Digraph&, const Node&) { } /// Next node. @@ -149,5 +158,5 @@ - /// The arc type of the digraph + /// Class for identifying an arc of the digraph /// This class identifies an arc of the digraph. It also serves @@ -158,6 +167,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Arc() { } /// Copy constructor. @@ -166,32 +175,32 @@ /// Arc(const Arc&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// Arc(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Arc) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Arc n) + /// bool operator!=(Arc) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the arcs; this order has nothing to do with the iteration - /// ordering of the arcs. + /// To allow the use of digraph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Arc) const { return false; } }; - /// Iterator class for the outgoing arcs of a node. + /// This iterator goes trough the outgoing arcs of a node. /// This iterator goes trough the \e outgoing arcs of a certain node @@ -199,15 +208,16 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing arcs of a node \c n - /// in a digraph \c g of type \c %Digraph as follows. + /// in digraph \c g of type \c Digraph as follows. ///\code /// int count=0; - /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class OutArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. OutArcIt() { } /// Copy constructor. @@ -216,20 +226,21 @@ /// OutArcIt(const OutArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// OutArcIt(Invalid) { } - /// Sets the iterator to the first outgoing arc. - - /// Sets the iterator to the first outgoing arc of the given node. - /// + /// This constructor sets the iterator to the first outgoing arc. + + /// This constructor sets the iterator to the first outgoing arc of + /// the node. OutArcIt(const Digraph&, const Node&) { } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given digraph. - /// + /// Arc -> OutArcIt conversion + + /// Sets the iterator to the value of the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. OutArcIt(const Digraph&, const Arc&) { } - /// Next outgoing arc + ///Next outgoing arc /// Assign the iterator to the next @@ -238,21 +249,22 @@ }; - /// Iterator class for the incoming arcs of a node. + /// This iterator goes trough the incoming arcs of a node. /// This iterator goes trough the \e incoming arcs of a certain node /// of a digraph. /// Its usage is quite simple, for example you can count the number - /// of incoming arcs of a node \c n - /// in a digraph \c g of type \c %Digraph as follows. + /// of outgoing arcs of a node \c n + /// in digraph \c g of type \c Digraph as follows. ///\code /// int count=0; - /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class InArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. InArcIt() { } /// Copy constructor. @@ -261,34 +273,34 @@ /// InArcIt(const InArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// InArcIt(Invalid) { } - /// Sets the iterator to the first incoming arc. - - /// Sets the iterator to the first incoming arc of the given node. - /// + /// This constructor sets the iterator to first incoming arc. + + /// This constructor set the iterator to the first incoming arc of + /// the node. InArcIt(const Digraph&, const Node&) { } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given digraph. - /// + /// Arc -> InArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. InArcIt(const Digraph&, const Arc&) { } /// Next incoming arc - /// Assign the iterator to the next - /// incoming arc of the corresponding node. + /// Assign the iterator to the next inarc of the corresponding node. + /// InArcIt& operator++() { return *this; } }; - - /// Iterator class for the arcs. - - /// This iterator goes through each arc of the digraph. + /// This iterator goes through each arc. + + /// This iterator goes through each arc of a digraph. /// Its usage is quite simple, for example you can count the number - /// of arcs in a digraph \c g of type \c %Digraph as follows: + /// of arcs in a digraph \c g of type \c Digraph as follows: ///\code /// int count=0; - /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count; + /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count; ///\endcode class ArcIt : public Arc { @@ -296,6 +308,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. ArcIt() { } /// Copy constructor. @@ -304,66 +316,56 @@ /// ArcIt(const ArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// ArcIt(Invalid) { } - /// Sets the iterator to the first arc. - - /// Sets the iterator to the first arc of the given digraph. - /// - explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given digraph. - /// + /// This constructor sets the iterator to the first arc. + + /// This constructor sets the iterator to the first arc of \c g. + ///@param g the digraph + ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } + /// Arc -> ArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. ArcIt(const Digraph&, const Arc&) { } - /// Next arc + ///Next arc /// Assign the iterator to the next arc. - /// ArcIt& operator++() { return *this; } }; - - /// \brief The source node of the arc. - /// - /// Returns the source node of the given arc. + ///Gives back the target node of an arc. + + ///Gives back the target node of an arc. + /// + Node target(Arc) const { return INVALID; } + ///Gives back the source node of an arc. + + ///Gives back the source node of an arc. + /// Node source(Arc) const { return INVALID; } - /// \brief The target node of the arc. - /// - /// Returns the target node of the given arc. - Node target(Arc) const { return INVALID; } - - /// \brief The ID of the node. - /// - /// Returns the ID of the given node. + /// \brief Returns the ID of the node. int id(Node) const { return -1; } - /// \brief The ID of the arc. - /// - /// Returns the ID of the given arc. + /// \brief Returns the ID of the arc. int id(Arc) const { return -1; } - /// \brief The node with the given ID. - /// - /// Returns the node with the given ID. - /// \pre The argument should be a valid node ID in the digraph. + /// \brief Returns the node with the given ID. + /// + /// \pre The argument should be a valid node ID in the graph. Node nodeFromId(int) const { return INVALID; } - /// \brief The arc with the given ID. - /// - /// Returns the arc with the given ID. - /// \pre The argument should be a valid arc ID in the digraph. + /// \brief Returns the arc with the given ID. + /// + /// \pre The argument should be a valid arc ID in the graph. Arc arcFromId(int) const { return INVALID; } - /// \brief An upper bound on the node IDs. - /// - /// Returns an upper bound on the node IDs. + /// \brief Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } - /// \brief An upper bound on the arc IDs. - /// - /// Returns an upper bound on the arc IDs. + /// \brief Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } @@ -391,44 +393,43 @@ int maxId(Arc) const { return -1; } - /// \brief The opposite node on the arc. - /// - /// Returns the opposite node on the given arc. - Node oppositeNode(Node, Arc) const { return INVALID; } - /// \brief The base node of the iterator. /// - /// Returns the base node of the given outgoing arc iterator - /// (i.e. the source node of the corresponding arc). - Node baseNode(OutArcIt) const { return INVALID; } + /// Gives back the base node of the iterator. + /// It is always the target of the pointed arc. + Node baseNode(const InArcIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Returns the running node of the given outgoing arc iterator - /// (i.e. the target node of the corresponding arc). - Node runningNode(OutArcIt) const { return INVALID; } + /// Gives back the running node of the iterator. + /// It is always the source of the pointed arc. + Node runningNode(const InArcIt&) const { return INVALID; } /// \brief The base node of the iterator. /// - /// Returns the base node of the given incomming arc iterator - /// (i.e. the target node of the corresponding arc). - Node baseNode(InArcIt) const { return INVALID; } + /// Gives back the base node of the iterator. + /// It is always the source of the pointed arc. + Node baseNode(const OutArcIt&) const { return INVALID; } /// \brief The running node of the iterator. /// - /// Returns the running node of the given incomming arc iterator - /// (i.e. the source node of the corresponding arc). - Node runningNode(InArcIt) const { return INVALID; } - - /// \brief Standard graph map type for the nodes. - /// - /// Standard graph map type for the nodes. - /// It conforms to the ReferenceMap concept. + /// Gives back the running node of the iterator. + /// It is always the target of the pointed arc. + Node runningNode(const OutArcIt&) const { return INVALID; } + + /// \brief The opposite node on the given arc. + /// + /// Gives back the opposite node on the given arc. + Node oppositeNode(const Node&, const Arc&) const { return INVALID; } + + /// \brief Reference map of the nodes to type \c T. + /// + /// Reference map of the nodes to type \c T. template class NodeMap : public ReferenceMap { public: - /// Constructor - explicit NodeMap(const Digraph&) { } - /// Constructor with given initial value + ///\e + NodeMap(const Digraph&) { } + ///\e NodeMap(const Digraph&, T) { } @@ -445,17 +446,15 @@ }; - /// \brief Standard graph map type for the arcs. - /// - /// Standard graph map type for the arcs. - /// It conforms to the ReferenceMap concept. + /// \brief Reference map of the arcs to type \c T. + /// + /// Reference map of the arcs to type \c T. template class ArcMap : public ReferenceMap { public: - /// Constructor - explicit ArcMap(const Digraph&) { } - /// Constructor with given initial value + ///\e + ArcMap(const Digraph&) { } + ///\e ArcMap(const Digraph&, T) { } - private: ///Copy constructor Index: lemon/concepts/graph.h =================================================================== --- lemon/concepts/graph.h (revision 734) +++ lemon/concepts/graph.h (revision 657) @@ -19,5 +19,5 @@ ///\ingroup graph_concepts ///\file -///\brief The concept of undirected graphs. +///\brief The concept of Undirected Graphs. #ifndef LEMON_CONCEPTS_GRAPH_H @@ -25,6 +25,4 @@ #include -#include -#include #include @@ -34,72 +32,61 @@ /// \ingroup graph_concepts /// - /// \brief Class describing the concept of undirected graphs. + /// \brief Class describing the concept of Undirected Graphs. /// - /// This class describes the common interface of all undirected - /// graphs. + /// This class describes the common interface of all Undirected + /// Graphs. /// - /// Like all concept classes, it only provides an interface - /// without any sensible implementation. So any general algorithm for - /// undirected graphs should compile with this class, but it will not + /// As all concept describing classes it provides only interface + /// without any sensible implementation. So any algorithm for + /// undirected graph should compile with this class, but it will not /// run properly, of course. - /// An actual graph implementation like \ref ListGraph or - /// \ref SmartGraph may have additional functionality. /// - /// The undirected graphs also fulfill the concept of \ref Digraph - /// "directed graphs", since each edge can also be regarded as two - /// oppositely directed arcs. - /// Undirected graphs provide an Edge type for the undirected edges and - /// an Arc type for the directed arcs. The Arc type is convertible to - /// Edge or inherited from it, i.e. the corresponding edge can be - /// obtained from an arc. - /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt - /// and ArcMap classes can be used for the arcs (just like in digraphs). - /// Both InArcIt and OutArcIt iterates on the same edges but with - /// opposite direction. IncEdgeIt also iterates on the same edges - /// as OutArcIt and InArcIt, but it is not convertible to Arc, - /// only to Edge. + /// The LEMON undirected graphs also fulfill the concept of + /// directed graphs (\ref lemon::concepts::Digraph "Digraph + /// Concept"). Each edges can be seen as two opposite + /// directed arc and consequently the undirected graph can be + /// seen as the direceted graph of these directed arcs. The + /// Graph has the Edge inner class for the edges and + /// the Arc type for the directed arcs. The Arc type is + /// convertible to Edge or inherited from it so from a directed + /// arc we can get the represented edge. /// - /// In LEMON, each undirected edge has an inherent orientation. - /// Thus it can defined if an arc is forward or backward oriented in - /// an undirected graph with respect to this default oriantation of - /// the represented edge. - /// With the direction() and direct() functions the direction - /// of an arc can be obtained and set, respectively. + /// In the sense of the LEMON each edge has a default + /// direction (it should be in every computer implementation, + /// because the order of edge's nodes defines an + /// orientation). With the default orientation we can define that + /// the directed arc is forward or backward directed. With the \c + /// direction() and \c direct() function we can get the direction + /// of the directed arc and we can direct an edge. /// - /// Only nodes and edges can be added to or removed from an undirected - /// graph and the corresponding arcs are added or removed automatically. - /// - /// \sa Digraph + /// The EdgeIt is an iterator for the edges. We can use + /// the EdgeMap to map values for the edges. The InArcIt and + /// OutArcIt iterates on the same edges but with opposite + /// direction. The IncEdgeIt iterates also on the same edges + /// as the OutArcIt and InArcIt but it is not convertible to Arc just + /// to Edge. class Graph { - private: - /// Graphs are \e not copy constructible. Use DigraphCopy instead. - Graph(const Graph&) {} - /// \brief Assignment of a graph to another one is \e not allowed. - /// Use DigraphCopy instead. - void operator=(const Graph&) {} - public: - /// Default constructor. - Graph() {} - - /// \brief Undirected graphs should be tagged with \c UndirectedTag. - /// - /// Undirected graphs should be tagged with \c UndirectedTag. - /// - /// This tag helps the \c enable_if technics to make compile time + /// \brief The undirected graph should be tagged by the + /// UndirectedTag. + /// + /// The undirected graph should be tagged by the UndirectedTag. This + /// tag helps the enable_if technics to make compile time /// specializations for undirected graphs. typedef True UndirectedTag; - /// The node type of the graph - - /// This class identifies a node of the graph. It also serves - /// as a base class of the node iterators, - /// thus they convert to this type. + /// \brief The base type of node iterators, + /// or in other words, the trivial node iterator. + /// + /// This is the base type of each node iterator, + /// thus each kind of node iterator converts to this. + /// More precisely each kind of node iterator should be inherited + /// from the trivial node iterator. class Node { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Node() { } /// Copy constructor. @@ -109,27 +96,27 @@ Node(const Node&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. + /// Invalid constructor \& conversion. + + /// This constructor initializes the iterator to be invalid. /// \sa Invalid for more details. Node(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Node) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Node n) + /// bool operator!=(Node) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of + /// To allow the use of graph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. @@ -138,9 +125,9 @@ }; - /// Iterator class for the nodes. - - /// This iterator goes through each node of the graph. + /// This iterator goes through each node. + + /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number - /// of nodes in a graph \c g of type \c %Graph like this: + /// of nodes in graph \c g of type \c Graph like this: ///\code /// int count=0; @@ -151,6 +138,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. NodeIt() { } /// Copy constructor. @@ -159,18 +146,20 @@ /// NodeIt(const NodeIt& n) : Node(n) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. + /// Invalid constructor \& conversion. + + /// Initialize the iterator to be invalid. /// \sa Invalid for more details. NodeIt(Invalid) { } /// Sets the iterator to the first node. - /// Sets the iterator to the first node of the given digraph. - /// - explicit NodeIt(const Graph&) { } - /// Sets the iterator to the given node. - - /// Sets the iterator to the given node of the given digraph. - /// + /// Sets the iterator to the first node of \c g. + /// + NodeIt(const Graph&) { } + /// Node -> NodeIt conversion. + + /// Sets the iterator to the node of \c the graph pointed by + /// the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. NodeIt(const Graph&, const Node&) { } /// Next node. @@ -182,15 +171,14 @@ - /// The edge type of the graph - - /// This class identifies an edge of the graph. It also serves - /// as a base class of the edge iterators, - /// thus they will convert to this type. + /// The base type of the edge iterators. + + /// The base type of the edge iterators. + /// class Edge { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Edge() { } /// Copy constructor. @@ -199,36 +187,36 @@ /// Edge(const Edge&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// Edge(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Edge) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Edge n) + /// bool operator!=(Edge) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the edges; this order has nothing to do with the iteration - /// ordering of the edges. + /// To allow the use of graph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Edge) const { return false; } }; - /// Iterator class for the edges. - - /// This iterator goes through each edge of the graph. + /// This iterator goes through each edge. + + /// This iterator goes through each edge of a graph. /// Its usage is quite simple, for example you can count the number - /// of edges in a graph \c g of type \c %Graph as follows: + /// of edges in a graph \c g of type \c Graph as follows: ///\code /// int count=0; @@ -239,6 +227,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. EdgeIt() { } /// Copy constructor. @@ -247,33 +235,36 @@ /// EdgeIt(const EdgeIt& e) : Edge(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// EdgeIt(Invalid) { } - /// Sets the iterator to the first edge. - - /// Sets the iterator to the first edge of the given graph. - /// - explicit EdgeIt(const Graph&) { } - /// Sets the iterator to the given edge. - - /// Sets the iterator to the given edge of the given graph. - /// + /// This constructor sets the iterator to the first edge. + + /// This constructor sets the iterator to the first edge. + EdgeIt(const Graph&) { } + /// Edge -> EdgeIt conversion + + /// Sets the iterator to the value of the trivial iterator. + /// This feature necessitates that each time we + /// iterate the edge-set, the iteration order is the + /// same. EdgeIt(const Graph&, const Edge&) { } /// Next edge /// Assign the iterator to the next edge. - /// EdgeIt& operator++() { return *this; } }; - /// Iterator class for the incident edges of a node. - - /// This iterator goes trough the incident undirected edges - /// of a certain node of a graph. + /// \brief This iterator goes trough the incident undirected + /// arcs of a node. + /// + /// This iterator goes trough the incident edges + /// of a certain node of a graph. You should assume that the + /// loop arcs will be iterated twice. + /// /// Its usage is quite simple, for example you can compute the - /// degree (i.e. the number of incident edges) of a node \c n - /// in a graph \c g of type \c %Graph as follows. + /// degree (i.e. count the number of incident arcs of a node \c n + /// in graph \c g of type \c Graph as follows. /// ///\code @@ -281,12 +272,10 @@ /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode - /// - /// \warning Loop edges will be iterated twice. class IncEdgeIt : public Edge { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. IncEdgeIt() { } /// Copy constructor. @@ -295,37 +284,38 @@ /// IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// IncEdgeIt(Invalid) { } - /// Sets the iterator to the first incident edge. - - /// Sets the iterator to the first incident edge of the given node. - /// + /// This constructor sets the iterator to first incident arc. + + /// This constructor set the iterator to the first incident arc of + /// the node. IncEdgeIt(const Graph&, const Node&) { } - /// Sets the iterator to the given edge. - - /// Sets the iterator to the given edge of the given graph. - /// + /// Edge -> IncEdgeIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. IncEdgeIt(const Graph&, const Edge&) { } - /// Next incident edge - - /// Assign the iterator to the next incident edge + /// Next incident arc + + /// Assign the iterator to the next incident arc /// of the corresponding node. IncEdgeIt& operator++() { return *this; } }; - /// The arc type of the graph - - /// This class identifies a directed arc of the graph. It also serves - /// as a base class of the arc iterators, - /// thus they will convert to this type. + /// The directed arc type. + + /// The directed arc type. It can be converted to the + /// edge or it should be inherited from the undirected + /// edge. class Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the object to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. Arc() { } /// Copy constructor. @@ -334,45 +324,41 @@ /// Arc(const Arc&) { } - /// %Invalid constructor \& conversion. - - /// Initializes the object to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// Arc(Invalid) { } /// Equality operator - /// Equality operator. - /// /// Two iterators are equal if and only if they point to the - /// same object or both are \c INVALID. + /// same object or both are invalid. bool operator==(Arc) const { return true; } /// Inequality operator - /// Inequality operator. + /// \sa operator==(Arc n) + /// bool operator!=(Arc) const { return true; } /// Artificial ordering operator. - /// Artificial ordering operator. - /// - /// \note This operator only has to define some strict ordering of - /// the arcs; this order has nothing to do with the iteration - /// ordering of the arcs. + /// To allow the use of graph descriptors as key type in std::map or + /// similar associative container we require this. + /// + /// \note This operator only have to define some strict ordering of + /// the items; this order has nothing to do with the iteration + /// ordering of the items. bool operator<(Arc) const { return false; } - /// Converison to \c Edge - - /// Converison to \c Edge. - /// + /// Converison to Edge operator Edge() const { return Edge(); } }; - - /// Iterator class for the arcs. - - /// This iterator goes through each directed arc of the graph. + /// This iterator goes through each directed arc. + + /// This iterator goes through each arc of a graph. /// Its usage is quite simple, for example you can count the number - /// of arcs in a graph \c g of type \c %Graph as follows: + /// of arcs in a graph \c g of type \c Graph as follows: ///\code /// int count=0; - /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count; + /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count; ///\endcode class ArcIt : public Arc { @@ -380,6 +366,6 @@ /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. ArcIt() { } /// Copy constructor. @@ -388,43 +374,44 @@ /// ArcIt(const ArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// ArcIt(Invalid) { } - /// Sets the iterator to the first arc. - - /// Sets the iterator to the first arc of the given graph. - /// - explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given graph. - /// + /// This constructor sets the iterator to the first arc. + + /// This constructor sets the iterator to the first arc of \c g. + ///@param g the graph + ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } + /// Arc -> ArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. ArcIt(const Graph&, const Arc&) { } - /// Next arc + ///Next arc /// Assign the iterator to the next arc. - /// ArcIt& operator++() { return *this; } }; - /// Iterator class for the outgoing arcs of a node. - - /// This iterator goes trough the \e outgoing directed arcs of a - /// certain node of a graph. + /// This iterator goes trough the outgoing directed arcs of a node. + + /// This iterator goes trough the \e outgoing arcs of a certain node + /// of a graph. /// Its usage is quite simple, for example you can count the number /// of outgoing arcs of a node \c n - /// in a graph \c g of type \c %Graph as follows. + /// in graph \c g of type \c Graph as follows. ///\code /// int count=0; - /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class OutArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. OutArcIt() { } /// Copy constructor. @@ -433,23 +420,26 @@ /// OutArcIt(const OutArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// OutArcIt(Invalid) { } - /// Sets the iterator to the first outgoing arc. - - /// Sets the iterator to the first outgoing arc of the given node. - /// + /// This constructor sets the iterator to the first outgoing arc. + + /// This constructor sets the iterator to the first outgoing arc of + /// the node. + ///@param n the node + ///@param g the graph OutArcIt(const Graph& n, const Node& g) { ignore_unused_variable_warning(n); ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given graph. - /// + /// Arc -> OutArcIt conversion + + /// Sets the iterator to the value of the trivial iterator. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. OutArcIt(const Graph&, const Arc&) { } - /// Next outgoing arc + ///Next outgoing arc /// Assign the iterator to the next @@ -458,21 +448,22 @@ }; - /// Iterator class for the incoming arcs of a node. - - /// This iterator goes trough the \e incoming directed arcs of a - /// certain node of a graph. + /// This iterator goes trough the incoming directed arcs of a node. + + /// This iterator goes trough the \e incoming arcs of a certain node + /// of a graph. /// Its usage is quite simple, for example you can count the number - /// of incoming arcs of a node \c n - /// in a graph \c g of type \c %Graph as follows. + /// of outgoing arcs of a node \c n + /// in graph \c g of type \c Graph as follows. ///\code /// int count=0; - /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; + /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count; ///\endcode + class InArcIt : public Arc { public: /// Default constructor - /// Default constructor. - /// \warning It sets the iterator to an undefined value. + /// @warning The default constructor sets the iterator + /// to an undefined value. InArcIt() { } /// Copy constructor. @@ -481,33 +472,35 @@ /// InArcIt(const InArcIt& e) : Arc(e) { } - /// %Invalid constructor \& conversion. - - /// Initializes the iterator to be invalid. - /// \sa Invalid for more details. + /// Initialize the iterator to be invalid. + + /// Initialize the iterator to be invalid. + /// InArcIt(Invalid) { } - /// Sets the iterator to the first incoming arc. - - /// Sets the iterator to the first incoming arc of the given node. - /// + /// This constructor sets the iterator to first incoming arc. + + /// This constructor set the iterator to the first incoming arc of + /// the node. + ///@param n the node + ///@param g the graph InArcIt(const Graph& g, const Node& n) { ignore_unused_variable_warning(n); ignore_unused_variable_warning(g); } - /// Sets the iterator to the given arc. - - /// Sets the iterator to the given arc of the given graph. - /// + /// Arc -> InArcIt conversion + + /// Sets the iterator to the value of the trivial iterator \c e. + /// This feature necessitates that each time we + /// iterate the arc-set, the iteration order is the same. InArcIt(const Graph&, const Arc&) { } /// Next incoming arc - /// Assign the iterator to the next - /// incoming arc of the corresponding node. + /// Assign the iterator to the next inarc of the corresponding node. + /// InArcIt& operator++() { return *this; } }; - /// \brief Standard graph map type for the nodes. - /// - /// Standard graph map type for the nodes. - /// It conforms to the ReferenceMap concept. + /// \brief Reference map of the nodes to type \c T. + /// + /// Reference map of the nodes to type \c T. template class NodeMap : public ReferenceMap @@ -515,7 +508,7 @@ public: - /// Constructor - explicit NodeMap(const Graph&) { } - /// Constructor with given initial value + ///\e + NodeMap(const Graph&) { } + ///\e NodeMap(const Graph&, T) { } @@ -532,8 +525,7 @@ }; - /// \brief Standard graph map type for the arcs. - /// - /// Standard graph map type for the arcs. - /// It conforms to the ReferenceMap concept. + /// \brief Reference map of the arcs to type \c T. + /// + /// Reference map of the arcs to type \c T. template class ArcMap : public ReferenceMap @@ -541,9 +533,8 @@ public: - /// Constructor - explicit ArcMap(const Graph&) { } - /// Constructor with given initial value + ///\e + ArcMap(const Graph&) { } + ///\e ArcMap(const Graph&, T) { } - private: ///Copy constructor @@ -558,8 +549,7 @@ }; - /// \brief Standard graph map type for the edges. - /// - /// Standard graph map type for the edges. - /// It conforms to the ReferenceMap concept. + /// Reference map of the edges to type \c T. + + /// Reference map of the edges to type \c T. template class EdgeMap : public ReferenceMap @@ -567,9 +557,8 @@ public: - /// Constructor - explicit EdgeMap(const Graph&) { } - /// Constructor with given initial value + ///\e + EdgeMap(const Graph&) { } + ///\e EdgeMap(const Graph&, T) { } - private: ///Copy constructor @@ -584,121 +573,104 @@ }; - /// \brief The first node of the edge. - /// - /// Returns the first node of the given edge. - /// - /// Edges don't have source and target nodes, however methods - /// u() and v() are used to query the two end-nodes of an edge. - /// The orientation of an edge that arises this way is called - /// the inherent direction, it is used to define the default - /// direction for the corresponding arcs. + /// \brief Direct the given edge. + /// + /// Direct the given edge. The returned arc source + /// will be the given node. + Arc direct(const Edge&, const Node&) const { + return INVALID; + } + + /// \brief Direct the given edge. + /// + /// Direct the given edge. The returned arc + /// represents the given edge and the direction comes + /// from the bool parameter. The source of the edge and + /// the directed arc is the same when the given bool is true. + Arc direct(const Edge&, bool) const { + return INVALID; + } + + /// \brief Returns true if the arc has default orientation. + /// + /// Returns whether the given directed arc is same orientation as + /// the corresponding edge's default orientation. + bool direction(Arc) const { return true; } + + /// \brief Returns the opposite directed arc. + /// + /// Returns the opposite directed arc. + Arc oppositeArc(Arc) const { return INVALID; } + + /// \brief Opposite node on an arc + /// + /// \return The opposite of the given node on the given edge. + Node oppositeNode(Node, Edge) const { return INVALID; } + + /// \brief First node of the edge. + /// + /// \return The first node of the given edge. + /// + /// Naturally edges don't have direction and thus + /// don't have source and target node. However we use \c u() and \c v() + /// methods to query the two nodes of the arc. The direction of the + /// arc which arises this way is called the inherent direction of the + /// edge, and is used to define the "default" direction + /// of the directed versions of the arcs. /// \sa v() /// \sa direction() Node u(Edge) const { return INVALID; } - /// \brief The second node of the edge. - /// - /// Returns the second node of the given edge. - /// - /// Edges don't have source and target nodes, however methods - /// u() and v() are used to query the two end-nodes of an edge. - /// The orientation of an edge that arises this way is called - /// the inherent direction, it is used to define the default - /// direction for the corresponding arcs. + /// \brief Second node of the edge. + /// + /// \return The second node of the given edge. + /// + /// Naturally edges don't have direction and thus + /// don't have source and target node. However we use \c u() and \c v() + /// methods to query the two nodes of the arc. The direction of the + /// arc which arises this way is called the inherent direction of the + /// edge, and is used to define the "default" direction + /// of the directed versions of the arcs. /// \sa u() /// \sa direction() Node v(Edge) const { return INVALID; } - /// \brief The source node of the arc. - /// - /// Returns the source node of the given arc. + /// \brief Source node of the directed arc. Node source(Arc) const { return INVALID; } - /// \brief The target node of the arc. - /// - /// Returns the target node of the given arc. + /// \brief Target node of the directed arc. Node target(Arc) const { return INVALID; } - /// \brief The ID of the node. - /// - /// Returns the ID of the given node. + /// \brief Returns the id of the node. int id(Node) const { return -1; } - /// \brief The ID of the edge. - /// - /// Returns the ID of the given edge. + /// \brief Returns the id of the edge. int id(Edge) const { return -1; } - /// \brief The ID of the arc. - /// - /// Returns the ID of the given arc. + /// \brief Returns the id of the arc. int id(Arc) const { return -1; } - /// \brief The node with the given ID. - /// - /// Returns the node with the given ID. - /// \pre The argument should be a valid node ID in the graph. + /// \brief Returns the node with the given id. + /// + /// \pre The argument should be a valid node id in the graph. Node nodeFromId(int) const { return INVALID; } - /// \brief The edge with the given ID. - /// - /// Returns the edge with the given ID. - /// \pre The argument should be a valid edge ID in the graph. + /// \brief Returns the edge with the given id. + /// + /// \pre The argument should be a valid edge id in the graph. Edge edgeFromId(int) const { return INVALID; } - /// \brief The arc with the given ID. - /// - /// Returns the arc with the given ID. - /// \pre The argument should be a valid arc ID in the graph. + /// \brief Returns the arc with the given id. + /// + /// \pre The argument should be a valid arc id in the graph. Arc arcFromId(int) const { return INVALID; } - /// \brief An upper bound on the node IDs. - /// - /// Returns an upper bound on the node IDs. + /// \brief Returns an upper bound on the node IDs. int maxNodeId() const { return -1; } - /// \brief An upper bound on the edge IDs. - /// - /// Returns an upper bound on the edge IDs. + /// \brief Returns an upper bound on the edge IDs. int maxEdgeId() const { return -1; } - /// \brief An upper bound on the arc IDs. - /// - /// Returns an upper bound on the arc IDs. + /// \brief Returns an upper bound on the arc IDs. int maxArcId() const { return -1; } - - /// \brief The direction of the arc. - /// - /// Returns \c true if the direction of the given arc is the same as - /// the inherent orientation of the represented edge. - bool direction(Arc) const { return true; } - - /// \brief Direct the edge. - /// - /// Direct the given edge. The returned arc - /// represents the given edge and its direction comes - /// from the bool parameter. If it is \c true, then the direction - /// of the arc is the same as the inherent orientation of the edge. - Arc direct(Edge, bool) const { - return INVALID; - } - - /// \brief Direct the edge. - /// - /// Direct the given edge. The returned arc represents the given - /// edge and its source node is the given node. - Arc direct(Edge, Node) const { - return INVALID; - } - - /// \brief The oppositely directed arc. - /// - /// Returns the oppositely directed arc representing the same edge. - Arc oppositeArc(Arc) const { return INVALID; } - - /// \brief The opposite node on the edge. - /// - /// Returns the opposite node on the given edge. - Node oppositeNode(Node, Edge) const { return INVALID; } void first(Node&) const {} @@ -734,37 +706,45 @@ int maxId(Arc) const { return -1; } - /// \brief The base node of the iterator. - /// - /// Returns the base node of the given incident edge iterator. - Node baseNode(IncEdgeIt) const { return INVALID; } - - /// \brief The running node of the iterator. - /// - /// Returns the running node of the given incident edge iterator. - Node runningNode(IncEdgeIt) const { return INVALID; } - - /// \brief The base node of the iterator. - /// - /// Returns the base node of the given outgoing arc iterator - /// (i.e. the source node of the corresponding arc). - Node baseNode(OutArcIt) const { return INVALID; } - - /// \brief The running node of the iterator. - /// - /// Returns the running node of the given outgoing arc iterator - /// (i.e. the target node of the corresponding arc). - Node runningNode(OutArcIt) const { return INVALID; } - - /// \brief The base node of the iterator. - /// - /// Returns the base node of the given incomming arc iterator - /// (i.e. the target node of the corresponding arc). - Node baseNode(InArcIt) const { return INVALID; } - - /// \brief The running node of the iterator. - /// - /// Returns the running node of the given incomming arc iterator - /// (i.e. the source node of the corresponding arc). - Node runningNode(InArcIt) const { return INVALID; } + /// \brief Base node of the iterator + /// + /// Returns the base node (the source in this case) of the iterator + Node baseNode(OutArcIt e) const { + return source(e); + } + /// \brief Running node of the iterator + /// + /// Returns the running node (the target in this case) of the + /// iterator + Node runningNode(OutArcIt e) const { + return target(e); + } + + /// \brief Base node of the iterator + /// + /// Returns the base node (the target in this case) of the iterator + Node baseNode(InArcIt e) const { + return target(e); + } + /// \brief Running node of the iterator + /// + /// Returns the running node (the source in this case) of the + /// iterator + Node runningNode(InArcIt e) const { + return source(e); + } + + /// \brief Base node of the iterator + /// + /// Returns the base node of the iterator + Node baseNode(IncEdgeIt) const { + return INVALID; + } + + /// \brief Running node of the iterator + /// + /// Returns the running node of the iterator + Node runningNode(IncEdgeIt) const { + return INVALID; + } template Index: lemon/concepts/graph_components.h =================================================================== --- lemon/concepts/graph_components.h (revision 734) +++ lemon/concepts/graph_components.h (revision 666) @@ -93,5 +93,5 @@ /// associative containers (e.g. \c std::map). /// - /// \note This operator only has to define some strict ordering of + /// \note This operator only have to define some strict ordering of /// the items; this order has nothing to do with the iteration /// ordering of the items. Index: lemon/concepts/heap.h =================================================================== --- lemon/concepts/heap.h (revision 710) +++ lemon/concepts/heap.h (revision 584) @@ -17,11 +17,11 @@ */ -#ifndef LEMON_CONCEPTS_HEAP_H -#define LEMON_CONCEPTS_HEAP_H - ///\ingroup concept ///\file ///\brief The concept of heaps. +#ifndef LEMON_CONCEPTS_HEAP_H +#define LEMON_CONCEPTS_HEAP_H + #include #include @@ -36,25 +36,19 @@ /// \brief The heap concept. /// - /// This concept class describes the main interface of heaps. - /// The various \ref heaps "heap structures" are efficient - /// implementations of the abstract data type \e priority \e queue. - /// They store items with specified values called \e priorities - /// in such a way that finding and removing the item with minimum - /// priority are efficient. The basic operations are adding and - /// erasing items, changing the priority of an item, etc. + /// Concept class describing the main interface of heaps. A \e heap + /// is a data structure for storing items with specified values called + /// \e priorities in such a way that finding the item with minimum + /// priority is efficient. In a heap one can change the priority of an + /// item, add or erase an item, etc. /// - /// Heaps are crucial in several algorithms, such as Dijkstra and Prim. - /// Any class that conforms to this concept can be used easily in such - /// algorithms. - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used + /// \tparam PR Type of the priority of the items. + /// \tparam IM A read and writable item map with int values, used /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. + /// \tparam Comp A functor class for the ordering of the priorities. /// The default is \c std::less. #ifdef DOXYGEN - template + template > #else - template > + template #endif class Heap { @@ -71,6 +65,7 @@ /// /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. + /// "pre heap" or "post heap". The later two are indifferent + /// from the point of view of the heap, but may be useful for + /// the user. /// /// The item-int map must be initialized in such way that it assigns @@ -78,58 +73,42 @@ enum State { IN_HEAP = 0, ///< = 0. The "in heap" state constant. - PRE_HEAP = -1, ///< = -1. The "pre-heap" state constant. - POST_HEAP = -2 ///< = -2. The "post-heap" state constant. + PRE_HEAP = -1, ///< = -1. The "pre heap" state constant. + POST_HEAP = -2 ///< = -2. The "post heap" state constant. }; - /// \brief Constructor. - /// - /// Constructor. + /// \brief The constructor. + /// + /// The constructor. /// \param map A map that assigns \c int values to keys of type /// \c Item. It is used internally by the heap implementations to /// handle the cross references. The assigned value must be - /// \c PRE_HEAP (-1) for each item. + /// \c PRE_HEAP (-1) for every item. explicit Heap(ItemIntMap &map) {} - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to keys of type - /// \c Item. It is used internally by the heap implementations to - /// handle the cross references. The assigned value must be - /// \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - explicit Heap(ItemIntMap &map, const CMP &comp) {} - /// \brief The number of items stored in the heap. /// - /// This function returns the number of items stored in the heap. + /// Returns the number of items stored in the heap. int size() const { return 0; } - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. + /// \brief Checks if the heap is empty. + /// + /// Returns \c true if the heap is empty. bool empty() const { return false; } - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() {} - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. + /// \brief Makes the heap empty. + /// + /// Makes the heap empty. + void clear(); + + /// \brief Inserts an item into the heap with the given priority. + /// + /// Inserts the given item into the heap with the given priority. /// \param i The item to insert. /// \param p The priority of the item. - /// \pre \e i must not be stored in the heap. void push(const Item &i, const Prio &p) {} - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. + /// \brief Returns the item having minimum priority. + /// + /// Returns the item having minimum priority. /// \pre The heap must be non-empty. Item top() const {} @@ -137,35 +116,33 @@ /// \brief The minimum priority. /// - /// This function returns the minimum priority. + /// Returns the minimum priority. /// \pre The heap must be non-empty. Prio prio() const {} - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. + /// \brief Removes the item having minimum priority. + /// + /// Removes the item having minimum priority. /// \pre The heap must be non-empty. void pop() {} - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. + /// \brief Removes an item from the heap. + /// + /// Removes the given item from the heap if it is already stored. /// \param i The item to delete. - /// \pre \e i must be in the heap. void erase(const Item &i) {} - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param i The item. - /// \pre \e i must be in the heap. + /// \brief The priority of an item. + /// + /// Returns the priority of the given item. + /// \param i The item. + /// \pre \c i must be in the heap. Prio operator[](const Item &i) const {} - /// \brief Set the priority of an item or insert it, if it is + /// \brief Sets the priority of an item or inserts it, if it is /// not stored in the heap. /// /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. + /// already stored in the heap. + /// Otherwise it inserts the given item with the given priority. /// /// \param i The item. @@ -173,21 +150,22 @@ void set(const Item &i, const Prio &p) {} - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. + /// \brief Decreases the priority of an item to the given value. + /// + /// Decreases the priority of an item to the given value. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at least \e p. + /// \pre \c i must be stored in the heap with priority at least \c p. void decrease(const Item &i, const Prio &p) {} - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. + /// \brief Increases the priority of an item to the given value. + /// + /// Increases the priority of an item to the given value. /// \param i The item. /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. + /// \pre \c i must be stored in the heap with priority at most \c p. void increase(const Item &i, const Prio &p) {} - /// \brief Return the state of an item. + /// \brief Returns if an item is in, has already been in, or has + /// never been in the heap. /// /// This method returns \c PRE_HEAP if the given item has never @@ -199,9 +177,9 @@ State state(const Item &i) const {} - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. + /// \brief Sets the state of an item in the heap. + /// + /// Sets the state of the given item in the heap. It can be used + /// to manually clear the heap when it is important to achive the + /// better time complexity. /// \param i The item. /// \param st The state. It should not be \c IN_HEAP. Index: lemon/concepts/maps.h =================================================================== --- lemon/concepts/maps.h (revision 718) +++ lemon/concepts/maps.h (revision 529) @@ -183,6 +183,5 @@ template struct Constraints { - typename enable_if::type - constraints() { + void constraints() { checkConcept, _ReferenceMap >(); ref = m[key]; Index: lemon/cplex.cc =================================================================== --- lemon/cplex.cc (revision 746) +++ lemon/cplex.cc (revision 576) @@ -112,37 +112,4 @@ } - int CplexBase::_addRow(Value lb, ExprIterator b, - ExprIterator e, Value ub) { - int i = CPXgetnumrows(cplexEnv(), _prob); - if (lb == -INF) { - const char s = 'L'; - CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0); - } else if (ub == INF) { - const char s = 'G'; - CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); - } else if (lb == ub){ - const char s = 'E'; - CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0); - } else { - const char s = 'R'; - double len = ub - lb; - CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0); - } - - std::vector indices; - std::vector rowlist; - std::vector values; - - for(ExprIterator it=b; it!=e; ++it) { - indices.push_back(it->first); - values.push_back(it->second); - rowlist.push_back(i); - } - - CPXchgcoeflist(cplexEnv(), _prob, values.size(), - &rowlist.front(), &indices.front(), &values.front()); - - return i; - } void CplexBase::_eraseCol(int i) { Index: lemon/cplex.h =================================================================== --- lemon/cplex.h (revision 746) +++ lemon/cplex.h (revision 576) @@ -94,5 +94,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: lemon/dfs.h =================================================================== --- lemon/dfs.h (revision 717) +++ lemon/dfs.h (revision 584) @@ -48,5 +48,5 @@ ///The type of the map that stores the predecessor ///arcs of the %DFS paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a \c PredMap. @@ -63,6 +63,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. - ///By default it is a NullMap. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. @@ -83,5 +82,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a \c ReachedMap. @@ -98,5 +97,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a \c DistMap. @@ -226,5 +225,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c PredMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap : public Dfs > { @@ -246,5 +245,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c DistMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap : public Dfs< Digraph, SetDistMapTraits > { @@ -266,5 +265,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ReachedMap type. - ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. template struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits > { @@ -286,5 +285,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ProcessedMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits > { @@ -413,6 +412,6 @@ ///The simplest way to execute the DFS algorithm is to use one of the ///member functions called \ref run(Node) "run()".\n - ///If you need better control on the execution, you have to call - ///\ref init() first, then you can add a source node with \ref addSource() + ///If you need more control on the execution, first you have to call + ///\ref init(), then you can add a source node with \ref addSource() ///and perform the actual computation with \ref start(). ///This procedure can be repeated if there are nodes that have not @@ -671,7 +670,7 @@ ///@{ - ///The DFS path to the given node. - - ///Returns the DFS path to the given node from the root(s). + ///The DFS path to a node. + + ///Returns the DFS path to a node. /// ///\warning \c t should be reached from the root(s). @@ -681,7 +680,7 @@ Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of the given node from the root(s). - - ///Returns the distance of the given node from the root(s). + ///The distance of a node from the root(s). + + ///Returns the distance of a node from the root(s). /// ///\warning If node \c v is not reached from the root(s), then @@ -692,5 +691,5 @@ int dist(Node v) const { return (*_dist)[v]; } - ///Returns the 'previous arc' of the %DFS tree for the given node. + ///Returns the 'previous arc' of the %DFS tree for a node. ///This function returns the 'previous arc' of the %DFS tree for the @@ -700,5 +699,5 @@ /// ///The %DFS tree used here is equal to the %DFS tree used in - ///\ref predNode() and \ref predMap(). + ///\ref predNode(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -706,13 +705,13 @@ Arc predArc(Node v) const { return (*_pred)[v];} - ///Returns the 'previous node' of the %DFS tree for the given node. + ///Returns the 'previous node' of the %DFS tree. ///This function returns the 'previous node' of the %DFS ///tree for the node \c v, i.e. it returns the last but one node - ///of a %DFS path from a root to \c v. It is \c INVALID + ///from a %DFS path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The %DFS tree used here is equal to the %DFS tree used in - ///\ref predArc() and \ref predMap(). + ///\ref predArc(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -735,5 +734,5 @@ /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the DFS tree (forest). + ///arcs, which form the DFS tree. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -741,5 +740,5 @@ const PredMap &predMap() const { return *_pred;} - ///Checks if the given node. node is reached from the root(s). + ///Checks if a node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). @@ -767,5 +766,5 @@ ///The type of the map that stores the predecessor ///arcs of the %DFS paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -782,5 +781,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; @@ -802,5 +801,5 @@ ///The type of the map that indicates which nodes are reached. - ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; ///Instantiates a ReachedMap. @@ -817,5 +816,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -832,5 +831,5 @@ ///The type of the DFS paths. - ///It must conform to the \ref concepts::Path "Path" concept. + ///It must meet the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; @@ -838,6 +837,10 @@ /// Default traits class used by DfsWizard - /// Default traits class used by DfsWizard. - /// \tparam GR The type of the digraph. + /// To make it easier to use Dfs algorithm + /// we have created a wizard class. + /// This \ref DfsWizard class needs default traits, + /// as well as the \ref Dfs class. + /// The \ref DfsWizardBase is a class to be the default traits of the + /// \ref DfsWizard class. template class DfsWizardBase : public DfsWizardDefaultTraits @@ -867,5 +870,5 @@ /// Constructor. - /// This constructor does not require parameters, it initiates + /// This constructor does not require parameters, therefore it initiates /// all of the attributes to \c 0. DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), @@ -897,4 +900,5 @@ typedef TR Base; + ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; @@ -904,8 +908,14 @@ typedef typename Digraph::OutArcIt OutArcIt; + ///\brief The type of the map that stores the predecessor + ///arcs of the DFS paths. typedef typename TR::PredMap PredMap; + ///\brief The type of the map that stores the distances of the nodes. typedef typename TR::DistMap DistMap; + ///\brief The type of the map that indicates which nodes are reached. typedef typename TR::ReachedMap ReachedMap; + ///\brief The type of the map that indicates which nodes are processed. typedef typename TR::ProcessedMap ProcessedMap; + ///The type of the DFS paths typedef typename TR::Path Path; @@ -990,10 +1000,9 @@ SetPredMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the predecessor map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the predecessor arcs of the nodes. + ///\brief \ref named-func-param "Named parameter" + ///for setting PredMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting PredMap object. template DfsWizard > predMap(const T &t) @@ -1009,10 +1018,9 @@ SetReachedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the reached map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are reached. + ///\brief \ref named-func-param "Named parameter" + ///for setting ReachedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ReachedMap object. template DfsWizard > reachedMap(const T &t) @@ -1028,11 +1036,9 @@ SetDistMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the distance map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the distances of the nodes calculated - ///by the algorithm. + ///\brief \ref named-func-param "Named parameter" + ///for setting DistMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting DistMap object. template DfsWizard > distMap(const T &t) @@ -1048,10 +1054,9 @@ SetProcessedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-func-param "Named parameter" for setting - ///the processed map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are processed. + ///\brief \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. template DfsWizard > processedMap(const T &t) @@ -1204,5 +1209,5 @@ /// /// The type of the map that indicates which nodes are reached. - /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. typedef typename Digraph::template NodeMap ReachedMap; @@ -1365,6 +1370,6 @@ /// The simplest way to execute the DFS algorithm is to use one of the /// member functions called \ref run(Node) "run()".\n - /// If you need better control on the execution, you have to call - /// \ref init() first, then you can add a source node with \ref addSource() + /// If you need more control on the execution, first you have to call + /// \ref init(), then you can add a source node with \ref addSource() /// and perform the actual computation with \ref start(). /// This procedure can be repeated if there are nodes that have not @@ -1616,5 +1621,5 @@ ///@{ - /// \brief Checks if the given node is reached from the root(s). + /// \brief Checks if a node is reached from the root(s). /// /// Returns \c true if \c v is reached from the root(s). Index: lemon/dijkstra.h =================================================================== --- lemon/dijkstra.h (revision 717) +++ lemon/dijkstra.h (revision 584) @@ -71,7 +71,7 @@ ///The type of the map that stores the arc lengths. - ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. + ///It must meet the \ref concepts::ReadMap "ReadMap" concept. typedef LEN LengthMap; - ///The type of the arc lengths. + ///The type of the length of the arcs. typedef typename LEN::Value Value; @@ -117,5 +117,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a \c PredMap. @@ -132,5 +132,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; @@ -152,5 +152,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a \c DistMap. @@ -169,8 +169,4 @@ /// \ingroup shortest_path ///This class provides an efficient implementation of the %Dijkstra algorithm. - /// - ///The %Dijkstra algorithm solves the single-source shortest path problem - ///when all arc lengths are non-negative. If there are negative lengths, - ///the BellmanFord algorithm should be used instead. /// ///The arc lengths are passed to the algorithm using a @@ -206,5 +202,5 @@ typedef typename TR::Digraph Digraph; - ///The type of the arc lengths. + ///The type of the length of the arcs. typedef typename TR::LengthMap::Value Value; ///The type of the map that stores the arc lengths. @@ -309,5 +305,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c PredMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetPredMap @@ -330,5 +326,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c DistMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetDistMap @@ -351,5 +347,5 @@ ///\ref named-templ-param "Named parameter" for setting ///\c ProcessedMap type. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. template struct SetProcessedMap @@ -448,5 +444,4 @@ ///\ref named-templ-param "Named parameter" for setting ///\c OperationTraits type. - /// For more information see \ref DijkstraDefaultOperationTraits. template struct SetOperationTraits @@ -590,6 +585,6 @@ ///The simplest way to execute the %Dijkstra algorithm is to use ///one of the member functions called \ref run(Node) "run()".\n - ///If you need better control on the execution, you have to call - ///\ref init() first, then you can add several source nodes with + ///If you need more control on the execution, first you have to call + ///\ref init(), then you can add several source nodes with ///\ref addSource(). Finally the actual path computation can be ///performed with one of the \ref start() functions. @@ -807,12 +802,12 @@ ///The results of the %Dijkstra algorithm can be obtained using these ///functions.\n - ///Either \ref run(Node) "run()" or \ref init() should be called + ///Either \ref run(Node) "run()" or \ref start() should be called ///before using them. ///@{ - ///The shortest path to the given node. - - ///Returns the shortest path to the given node from the root(s). + ///The shortest path to a node. + + ///Returns the shortest path to a node. /// ///\warning \c t should be reached from the root(s). @@ -822,7 +817,7 @@ Path path(Node t) const { return Path(*G, *_pred, t); } - ///The distance of the given node from the root(s). - - ///Returns the distance of the given node from the root(s). + ///The distance of a node from the root(s). + + ///Returns the distance of a node from the root(s). /// ///\warning If node \c v is not reached from the root(s), then @@ -833,7 +828,6 @@ Value dist(Node v) const { return (*_dist)[v]; } - ///\brief Returns the 'previous arc' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous arc' of the shortest path tree for a node. + ///This function returns the 'previous arc' of the shortest path ///tree for the node \c v, i.e. it returns the last arc of a @@ -842,5 +836,5 @@ /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predNode() and \ref predMap(). + ///tree used in \ref predNode(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -848,14 +842,13 @@ Arc predArc(Node v) const { return (*_pred)[v]; } - ///\brief Returns the 'previous node' of the shortest path tree for - ///the given node. - /// + ///Returns the 'previous node' of the shortest path tree for a node. + ///This function returns the 'previous node' of the shortest path ///tree for the node \c v, i.e. it returns the last but one node - ///of a shortest path from a root to \c v. It is \c INVALID + ///from a shortest path from a root to \c v. It is \c INVALID ///if \c v is not reached from the root(s) or if \c v is a root. /// ///The shortest path tree used here is equal to the shortest path - ///tree used in \ref predArc() and \ref predMap(). + ///tree used in \ref predArc(). /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -878,5 +871,5 @@ /// ///Returns a const reference to the node map that stores the predecessor - ///arcs, which form the shortest path tree (forest). + ///arcs, which form the shortest path tree. /// ///\pre Either \ref run(Node) "run()" or \ref init() @@ -884,5 +877,5 @@ const PredMap &predMap() const { return *_pred;} - ///Checks if the given node is reached from the root(s). + ///Checks if a node is reached from the root(s). ///Returns \c true if \c v is reached from the root(s). @@ -903,7 +896,7 @@ Heap::POST_HEAP; } - ///The current distance of the given node from the root(s). - - ///Returns the current distance of the given node from the root(s). + ///The current distance of a node from the root(s). + + ///Returns the current distance of a node from the root(s). ///It may be decreased in the following processes. /// @@ -932,7 +925,7 @@ ///The type of the map that stores the arc lengths. - ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. + ///It must meet the \ref concepts::ReadMap "ReadMap" concept. typedef LEN LengthMap; - ///The type of the arc lengths. + ///The type of the length of the arcs. typedef typename LEN::Value Value; @@ -981,5 +974,5 @@ ///The type of the map that stores the predecessor ///arcs of the shortest paths. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap PredMap; ///Instantiates a PredMap. @@ -996,5 +989,5 @@ ///The type of the map that indicates which nodes are processed. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. typedef NullMap ProcessedMap; @@ -1016,5 +1009,5 @@ ///The type of the map that stores the distances of the nodes. - ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. + ///It must meet the \ref concepts::WriteMap "WriteMap" concept. typedef typename Digraph::template NodeMap DistMap; ///Instantiates a DistMap. @@ -1031,5 +1024,5 @@ ///The type of the shortest paths. - ///It must conform to the \ref concepts::Path "Path" concept. + ///It must meet the \ref concepts::Path "Path" concept. typedef lemon::Path Path; }; @@ -1037,7 +1030,10 @@ /// Default traits class used by DijkstraWizard - /// Default traits class used by DijkstraWizard. - /// \tparam GR The type of the digraph. - /// \tparam LEN The type of the length map. + /// To make it easier to use Dijkstra algorithm + /// we have created a wizard class. + /// This \ref DijkstraWizard class needs default traits, + /// as well as the \ref Dijkstra class. + /// The \ref DijkstraWizardBase is a class to be the default traits of the + /// \ref DijkstraWizard class. template class DijkstraWizardBase : public DijkstraWizardDefaultTraits @@ -1098,4 +1094,5 @@ typedef TR Base; + ///The type of the digraph the algorithm runs on. typedef typename TR::Digraph Digraph; @@ -1105,10 +1102,18 @@ typedef typename Digraph::OutArcIt OutArcIt; + ///The type of the map that stores the arc lengths. typedef typename TR::LengthMap LengthMap; + ///The type of the length of the arcs. typedef typename LengthMap::Value Value; + ///\brief The type of the map that stores the predecessor + ///arcs of the shortest paths. typedef typename TR::PredMap PredMap; + ///The type of the map that stores the distances of the nodes. typedef typename TR::DistMap DistMap; + ///The type of the map that indicates which nodes are processed. typedef typename TR::ProcessedMap ProcessedMap; + ///The type of the shortest paths typedef typename TR::Path Path; + ///The heap type used by the dijkstra algorithm. typedef typename TR::Heap Heap; @@ -1182,10 +1187,9 @@ SetPredMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the predecessor map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the predecessor arcs of the nodes. + ///\brief \ref named-func-param "Named parameter" + ///for setting PredMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting PredMap object. template DijkstraWizard > predMap(const T &t) @@ -1201,11 +1205,9 @@ SetDistMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-templ-param "Named parameter" for setting - ///the distance map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that stores the distances of the nodes calculated - ///by the algorithm. + ///\brief \ref named-func-param "Named parameter" + ///for setting DistMap object. + /// + ///\ref named-func-param "Named parameter" + ///for setting DistMap object. template DijkstraWizard > distMap(const T &t) @@ -1221,10 +1223,9 @@ SetProcessedMapBase(const TR &b) : TR(b) {} }; - - ///\brief \ref named-func-param "Named parameter" for setting - ///the processed map. - /// - ///\ref named-templ-param "Named parameter" function for setting - ///the map that indicates which nodes are processed. + ///\brief \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. + /// + /// \ref named-func-param "Named parameter" + ///for setting ProcessedMap object. template DijkstraWizard > processedMap(const T &t) @@ -1239,5 +1240,4 @@ SetPathBase(const TR &b) : TR(b) {} }; - ///\brief \ref named-func-param "Named parameter" ///for getting the shortest path to the target node. Index: lemon/dim2.h =================================================================== --- lemon/dim2.h (revision 714) +++ lemon/dim2.h (revision 440) @@ -22,7 +22,14 @@ #include -///\ingroup geomdat +///\ingroup misc ///\file ///\brief A simple two dimensional vector and a bounding box implementation +/// +/// The class \ref lemon::dim2::Point "dim2::Point" implements +/// a two dimensional vector with the usual operations. +/// +/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine +/// the rectangular bounding box of a set of +/// \ref lemon::dim2::Point "dim2::Point"'s. namespace lemon { @@ -34,5 +41,5 @@ namespace dim2 { - /// \addtogroup geomdat + /// \addtogroup misc /// @{ Index: mon/fib_heap.h =================================================================== --- lemon/fib_heap.h (revision 711) +++ (revision ) @@ -1,475 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_FIB_HEAP_H -#define LEMON_FIB_HEAP_H - -///\file -///\ingroup heaps -///\brief Fibonacci heap implementation. - -#include -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - /// \brief Fibonacci heap data structure. - /// - /// This class implements the \e Fibonacci \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The methods \ref increase() and \ref erase() are not efficient in a - /// Fibonacci heap. In case of many calls of these operations, it is - /// better to use other heap structure, e.g. \ref BinHeap "binary heap". - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. -#ifdef DOXYGEN - template -#else - template > -#endif - class FibHeap { - public: - - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - private: - class Store; - - std::vector _data; - int _minimum; - ItemIntMap &_iim; - Compare _comp; - int _num; - - public: - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit FibHeap(ItemIntMap &map) - : _minimum(0), _iim(map), _num() {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - FibHeap(ItemIntMap &map, const Compare &comp) - : _minimum(0), _iim(map), _comp(comp), _num() {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _num; } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _num==0; } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { - _data.clear(); _minimum = 0; _num = 0; - } - - /// \brief Insert an item into the heap with the given priority. - /// - /// This function inserts the given item into the heap with the - /// given priority. - /// \param item The item to insert. - /// \param prio The priority of the item. - /// \pre \e item must not be stored in the heap. - void push (const Item& item, const Prio& prio) { - int i=_iim[item]; - if ( i < 0 ) { - int s=_data.size(); - _iim.set( item, s ); - Store st; - st.name=item; - _data.push_back(st); - i=s; - } else { - _data[i].parent=_data[i].child=-1; - _data[i].degree=0; - _data[i].in=true; - _data[i].marked=false; - } - - if ( _num ) { - _data[_data[_minimum].right_neighbor].left_neighbor=i; - _data[i].right_neighbor=_data[_minimum].right_neighbor; - _data[_minimum].right_neighbor=i; - _data[i].left_neighbor=_minimum; - if ( _comp( prio, _data[_minimum].prio) ) _minimum=i; - } else { - _data[i].right_neighbor=_data[i].left_neighbor=i; - _minimum=i; - } - _data[i].prio=prio; - ++_num; - } - - /// \brief Return the item having minimum priority. - /// - /// This function returns the item having minimum priority. - /// \pre The heap must be non-empty. - Item top() const { return _data[_minimum].name; } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { return _data[_minimum].prio; } - - /// \brief Remove the item having minimum priority. - /// - /// This function removes the item having minimum priority. - /// \pre The heap must be non-empty. - void pop() { - /*The first case is that there are only one root.*/ - if ( _data[_minimum].left_neighbor==_minimum ) { - _data[_minimum].in=false; - if ( _data[_minimum].degree!=0 ) { - makeRoot(_data[_minimum].child); - _minimum=_data[_minimum].child; - balance(); - } - } else { - int right=_data[_minimum].right_neighbor; - unlace(_minimum); - _data[_minimum].in=false; - if ( _data[_minimum].degree > 0 ) { - int left=_data[_minimum].left_neighbor; - int child=_data[_minimum].child; - int last_child=_data[child].left_neighbor; - - makeRoot(child); - - _data[left].right_neighbor=child; - _data[child].left_neighbor=left; - _data[right].left_neighbor=last_child; - _data[last_child].right_neighbor=right; - } - _minimum=right; - balance(); - } // the case where there are more roots - --_num; - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param item The item to delete. - /// \pre \e item must be in the heap. - void erase (const Item& item) { - int i=_iim[item]; - - if ( i >= 0 && _data[i].in ) { - if ( _data[i].parent!=-1 ) { - int p=_data[i].parent; - cut(i,p); - cascade(p); - } - _minimum=i; //As if its prio would be -infinity - pop(); - } - } - - /// \brief The priority of the given item. - /// - /// This function returns the priority of the given item. - /// \param item The item. - /// \pre \e item must be in the heap. - Prio operator[](const Item& item) const { - return _data[_iim[item]].prio; - } - - /// \brief Set the priority of an item or insert it, if it is - /// not stored in the heap. - /// - /// This method sets the priority of the given item if it is - /// already stored in the heap. Otherwise it inserts the given - /// item into the heap with the given priority. - /// \param item The item. - /// \param prio The priority. - void set (const Item& item, const Prio& prio) { - int i=_iim[item]; - if ( i >= 0 && _data[i].in ) { - if ( _comp(prio, _data[i].prio) ) decrease(item, prio); - if ( _comp(_data[i].prio, prio) ) increase(item, prio); - } else push(item, prio); - } - - /// \brief Decrease the priority of an item to the given value. - /// - /// This function decreases the priority of an item to the given value. - /// \param item The item. - /// \param prio The priority. - /// \pre \e item must be stored in the heap with priority at least \e prio. - void decrease (const Item& item, const Prio& prio) { - int i=_iim[item]; - _data[i].prio=prio; - int p=_data[i].parent; - - if ( p!=-1 && _comp(prio, _data[p].prio) ) { - cut(i,p); - cascade(p); - } - if ( _comp(prio, _data[_minimum].prio) ) _minimum=i; - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param item The item. - /// \param prio The priority. - /// \pre \e item must be stored in the heap with priority at most \e prio. - void increase (const Item& item, const Prio& prio) { - erase(item); - push(item, prio); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param item The item. - State state(const Item &item) const { - int i=_iim[item]; - if( i>=0 ) { - if ( _data[i].in ) i=0; - else i=-2; - } - return State(i); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) { - erase(i); - } - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - private: - - void balance() { - - int maxdeg=int( std::floor( 2.08*log(double(_data.size()))))+1; - - std::vector A(maxdeg,-1); - - /* - *Recall that now minimum does not point to the minimum prio element. - *We set minimum to this during balance(). - */ - int anchor=_data[_minimum].left_neighbor; - int next=_minimum; - bool end=false; - - do { - int active=next; - if ( anchor==active ) end=true; - int d=_data[active].degree; - next=_data[active].right_neighbor; - - while (A[d]!=-1) { - if( _comp(_data[active].prio, _data[A[d]].prio) ) { - fuse(active,A[d]); - } else { - fuse(A[d],active); - active=A[d]; - } - A[d]=-1; - ++d; - } - A[d]=active; - } while ( !end ); - - - while ( _data[_minimum].parent >=0 ) - _minimum=_data[_minimum].parent; - int s=_minimum; - int m=_minimum; - do { - if ( _comp(_data[s].prio, _data[_minimum].prio) ) _minimum=s; - s=_data[s].right_neighbor; - } while ( s != m ); - } - - void makeRoot(int c) { - int s=c; - do { - _data[s].parent=-1; - s=_data[s].right_neighbor; - } while ( s != c ); - } - - void cut(int a, int b) { - /* - *Replacing a from the children of b. - */ - --_data[b].degree; - - if ( _data[b].degree !=0 ) { - int child=_data[b].child; - if ( child==a ) - _data[b].child=_data[child].right_neighbor; - unlace(a); - } - - - /*Lacing a to the roots.*/ - int right=_data[_minimum].right_neighbor; - _data[_minimum].right_neighbor=a; - _data[a].left_neighbor=_minimum; - _data[a].right_neighbor=right; - _data[right].left_neighbor=a; - - _data[a].parent=-1; - _data[a].marked=false; - } - - void cascade(int a) { - if ( _data[a].parent!=-1 ) { - int p=_data[a].parent; - - if ( _data[a].marked==false ) _data[a].marked=true; - else { - cut(a,p); - cascade(p); - } - } - } - - void fuse(int a, int b) { - unlace(b); - - /*Lacing b under a.*/ - _data[b].parent=a; - - if (_data[a].degree==0) { - _data[b].left_neighbor=b; - _data[b].right_neighbor=b; - _data[a].child=b; - } else { - int child=_data[a].child; - int last_child=_data[child].left_neighbor; - _data[child].left_neighbor=b; - _data[b].right_neighbor=child; - _data[last_child].right_neighbor=b; - _data[b].left_neighbor=last_child; - } - - ++_data[a].degree; - - _data[b].marked=false; - } - - /* - *It is invoked only if a has siblings. - */ - void unlace(int a) { - int leftn=_data[a].left_neighbor; - int rightn=_data[a].right_neighbor; - _data[leftn].right_neighbor=rightn; - _data[rightn].left_neighbor=leftn; - } - - - class Store { - friend class FibHeap; - - Item name; - int parent; - int left_neighbor; - int right_neighbor; - int child; - int degree; - bool marked; - bool in; - Prio prio; - - Store() : parent(-1), child(-1), degree(), marked(false), in(true) {} - }; - }; - -} //namespace lemon - -#endif //LEMON_FIB_HEAP_H - Index: mon/fourary_heap.h =================================================================== --- lemon/fourary_heap.h (revision 706) +++ (revision ) @@ -1,342 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_FOURARY_HEAP_H -#define LEMON_FOURARY_HEAP_H - -///\ingroup heaps -///\file -///\brief Fourary heap implementation. - -#include -#include -#include - -namespace lemon { - - /// \ingroup heaps - /// - ///\brief Fourary heap data structure. - /// - /// This class implements the \e fourary \e heap data structure. - /// It fully conforms to the \ref concepts::Heap "heap concept". - /// - /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap" - /// for K=4. It is similar to the \ref BinHeap "binary heap", - /// but its nodes have at most four children, instead of two. - /// - /// \tparam PR Type of the priorities of the items. - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - /// \tparam CMP A functor class for comparing the priorities. - /// The default is \c std::less. - /// - ///\sa BinHeap - ///\sa KaryHeap -#ifdef DOXYGEN - template -#else - template > -#endif - class FouraryHeap { - public: - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef PR Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - /// Type of the item-priority pairs. - typedef std::pair Pair; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - std::vector _data; - Compare _comp; - ItemIntMap &_iim; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit FouraryHeap(ItemIntMap &map) : _iim(map) {} - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \param comp The function object used for comparing the priorities. - FouraryHeap(ItemIntMap &map, const Compare &comp) - : _iim(map), _comp(comp) {} - - /// \brief The number of items stored in the heap. - /// - /// This function returns the number of items stored in the heap. - int size() const { return _data.size(); } - - /// \brief Check if the heap is empty. - /// - /// This function returns \c true if the heap is empty. - bool empty() const { return _data.empty(); } - - /// \brief Make the heap empty. - /// - /// This functon makes the heap empty. - /// It does not change the cross reference map. If you want to reuse - /// a heap that is not surely empty, you should first clear it and - /// then you should set the cross reference map to \c PRE_HEAP - /// for each item. - void clear() { _data.clear(); } - - private: - static int parent(int i) { return (i-1)/4; } - static int firstChild(int i) { return 4*i+1; } - - bool less(const Pair &p1, const Pair &p2) const { - return _comp(p1.second, p2.second); - } - - void bubbleUp(int hole, Pair p) { - int par = parent(hole); - while( hole>0 && less(p,_data[par]) ) { - move(_data[par],hole); - hole = par; - par = parent(hole); - } - move(p, hole); - } - - void bubbleDown(int hole, Pair p, int length) { - if( length>1 ) { - int child = firstChild(hole); - while( child+30) bubbleDown(0, _data[n], n); - _data.pop_back(); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. - void erase(const Item &i) { - int h = _iim[i]; - int n = _data.size()-1; - _iim.set(_data[h].first, POST_HEAP); - if( h=0) s=0; - return State(s); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) erase(i); - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - /// \brief Replace an item in the heap. - /// - /// This function replaces item \c i with item \c j. - /// Item \c i must be in the heap, while \c j must be out of the heap. - /// After calling this method, item \c i will be out of the - /// heap and \c j will be in the heap with the same prioriority - /// as item \c i had before. - void replace(const Item& i, const Item& j) { - int idx = _iim[i]; - _iim.set(i, _iim[j]); - _iim.set(j, idx); - _data[idx].first = j; - } - - }; // class FouraryHeap - -} // namespace lemon - -#endif // LEMON_FOURARY_HEAP_H Index: lemon/full_graph.h =================================================================== --- lemon/full_graph.h (revision 735) +++ lemon/full_graph.h (revision 617) @@ -25,5 +25,5 @@ ///\ingroup graphs ///\file -///\brief FullDigraph and FullGraph classes. +///\brief FullGraph and FullDigraph classes. namespace lemon { @@ -149,24 +149,22 @@ /// \ingroup graphs /// - /// \brief A directed full graph class. - /// - /// FullDigraph is a simple and fast implmenetation of directed full - /// (complete) graphs. It contains an arc from each node to each node - /// (including a loop for each node), therefore the number of arcs - /// is the square of the number of nodes. - /// This class is completely static and it needs constant memory space. - /// Thus you can neither add nor delete nodes or arcs, however - /// the structure can be resized using resize(). - /// - /// This type fully conforms to the \ref concepts::Digraph "Digraph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// \note FullDigraph and FullGraph classes are very similar, + /// \brief A full digraph class. + /// + /// This is a simple and fast directed full graph implementation. + /// From each node go arcs to each node (including the source node), + /// therefore the number of the arcs in the digraph is the square of + /// the node number. This digraph type is completely static, so you + /// can neither add nor delete either arcs or nodes, and it needs + /// constant space in memory. + /// + /// This class fully conforms to the \ref concepts::Digraph + /// "Digraph concept". + /// + /// The \c FullDigraph and \c FullGraph classes are very similar, /// but there are two differences. While this class conforms only - /// to the \ref concepts::Digraph "Digraph" concept, FullGraph - /// conforms to the \ref concepts::Graph "Graph" concept, - /// moreover FullGraph does not contain a loop for each - /// node as this class does. + /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph + /// class conforms to the \ref concepts::Graph "Graph" concept, + /// moreover \c FullGraph does not contain a loop arc for each + /// node as \c FullDigraph does. /// /// \sa FullGraph @@ -176,7 +174,5 @@ public: - /// \brief Default constructor. - /// - /// Default constructor. The number of nodes and arcs will be zero. + /// \brief Constructor FullDigraph() { construct(0); } @@ -189,6 +185,6 @@ /// \brief Resizes the digraph /// - /// This function resizes the digraph. It fully destroys and - /// rebuilds the structure, therefore the maps of the digraph will be + /// Resizes the digraph. The function will fully destroy and + /// rebuild the digraph. This cause that the maps of the digraph will /// reallocated automatically and the previous values will be lost. void resize(int n) { @@ -202,7 +198,7 @@ /// \brief Returns the node with the given index. /// - /// Returns the node with the given index. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. + /// Returns the node with the given index. Since it is a static + /// digraph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } @@ -210,14 +206,14 @@ /// \brief Returns the index of the given node. /// - /// Returns the index of the given node. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. - /// \sa operator()() - int index(Node node) const { return Parent::index(node); } + /// Returns the index of the given node. Since it is a static + /// digraph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. + /// \sa operator() + int index(const Node& node) const { return Parent::index(node); } /// \brief Returns the arc connecting the given nodes. /// /// Returns the arc connecting the given nodes. - Arc arc(Node u, Node v) const { + Arc arc(const Node& u, const Node& v) const { return Parent::arc(u, v); } @@ -525,21 +521,19 @@ /// \brief An undirected full graph class. /// - /// FullGraph is a simple and fast implmenetation of undirected full - /// (complete) graphs. It contains an edge between every distinct pair - /// of nodes, therefore the number of edges is n(n-1)/2. - /// This class is completely static and it needs constant memory space. - /// Thus you can neither add nor delete nodes or edges, however - /// the structure can be resized using resize(). - /// - /// This type fully conforms to the \ref concepts::Graph "Graph concept". - /// Most of its member functions and nested classes are documented - /// only in the concept class. - /// - /// \note FullDigraph and FullGraph classes are very similar, - /// but there are two differences. While FullDigraph + /// This is a simple and fast undirected full graph + /// implementation. From each node go edge to each other node, + /// therefore the number of edges in the graph is \f$n(n-1)/2\f$. + /// This graph type is completely static, so you can neither + /// add nor delete either edges or nodes, and it needs constant + /// space in memory. + /// + /// This class fully conforms to the \ref concepts::Graph "Graph concept". + /// + /// The \c FullGraph and \c FullDigraph classes are very similar, + /// but there are two differences. While the \c FullDigraph class /// conforms only to the \ref concepts::Digraph "Digraph" concept, /// this class conforms to the \ref concepts::Graph "Graph" concept, - /// moreover this class does not contain a loop for each - /// node as FullDigraph does. + /// moreover \c FullGraph does not contain a loop arc for each + /// node as \c FullDigraph does. /// /// \sa FullDigraph @@ -549,7 +543,5 @@ public: - /// \brief Default constructor. - /// - /// Default constructor. The number of nodes and edges will be zero. + /// \brief Constructor FullGraph() { construct(0); } @@ -562,6 +554,6 @@ /// \brief Resizes the graph /// - /// This function resizes the graph. It fully destroys and - /// rebuilds the structure, therefore the maps of the graph will be + /// Resizes the graph. The function will fully destroy and + /// rebuild the graph. This cause that the maps of the graph will /// reallocated automatically and the previous values will be lost. void resize(int n) { @@ -577,7 +569,7 @@ /// \brief Returns the node with the given index. /// - /// Returns the node with the given index. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. + /// Returns the node with the given index. Since it is a static + /// graph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } @@ -585,21 +577,21 @@ /// \brief Returns the index of the given node. /// - /// Returns the index of the given node. Since this structure is - /// completely static, the nodes can be indexed with integers from - /// the range [0..nodeNum()-1]. - /// \sa operator()() - int index(Node node) const { return Parent::index(node); } + /// Returns the index of the given node. Since it is a static + /// graph its nodes can be indexed with integers from the range + /// [0..nodeNum()-1]. + /// \sa operator() + int index(const Node& node) const { return Parent::index(node); } /// \brief Returns the arc connecting the given nodes. /// /// Returns the arc connecting the given nodes. - Arc arc(Node s, Node t) const { + Arc arc(const Node& s, const Node& t) const { return Parent::arc(s, t); } - /// \brief Returns the edge connecting the given nodes. - /// - /// Returns the edge connecting the given nodes. - Edge edge(Node u, Node v) const { + /// \brief Returns the edge connects the given nodes. + /// + /// Returns the edge connects the given nodes. + Edge edge(const Node& u, const Node& v) const { return Parent::edge(u, v); } Index: lemon/glpk.cc =================================================================== --- lemon/glpk.cc (revision 746) +++ lemon/glpk.cc (revision 576) @@ -57,40 +57,4 @@ int i = glp_add_rows(lp, 1); glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0); - return i; - } - - int GlpkBase::_addRow(Value lo, ExprIterator b, - ExprIterator e, Value up) { - int i = glp_add_rows(lp, 1); - - if (lo == -INF) { - if (up == INF) { - glp_set_row_bnds(lp, i, GLP_FR, lo, up); - } else { - glp_set_row_bnds(lp, i, GLP_UP, lo, up); - } - } else { - if (up == INF) { - glp_set_row_bnds(lp, i, GLP_LO, lo, up); - } else if (lo != up) { - glp_set_row_bnds(lp, i, GLP_DB, lo, up); - } else { - glp_set_row_bnds(lp, i, GLP_FX, lo, up); - } - } - - std::vector indexes; - std::vector values; - - indexes.push_back(0); - values.push_back(0); - - for(ExprIterator it = b; it != e; ++it) { - indexes.push_back(it->first); - values.push_back(it->second); - } - - glp_set_mat_row(lp, i, values.size() - 1, - &indexes.front(), &values.front()); return i; } Index: lemon/glpk.h =================================================================== --- lemon/glpk.h (revision 746) +++ lemon/glpk.h (revision 650) @@ -55,5 +55,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: lemon/gomory_hu.h =================================================================== --- lemon/gomory_hu.h (revision 713) +++ lemon/gomory_hu.h (revision 596) @@ -360,8 +360,8 @@ /// \c t. /// \code - /// GomoryHu gom(g, capacities); + /// GomoruHu gom(g, capacities); /// gom.run(); /// int cnt=0; - /// for(GomoryHu::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; + /// for(GomoruHu::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; /// \endcode class MinCutNodeIt @@ -457,8 +457,8 @@ /// \c t. /// \code - /// GomoryHu gom(g, capacities); + /// GomoruHu gom(g, capacities); /// gom.run(); /// int value=0; - /// for(GomoryHu::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) + /// for(GomoruHu::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) /// value+=capacities[e]; /// \endcode Index: lemon/grid_graph.h =================================================================== --- lemon/grid_graph.h (revision 735) +++ lemon/grid_graph.h (revision 617) @@ -471,19 +471,15 @@ /// \brief Grid graph class /// - /// 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 [0..width()-1] and j is in the range - /// [0..height()-1]. 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 + /// 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 /// 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 @@ -501,7 +497,6 @@ ///\endcode /// - /// 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. + /// This graph type fully conforms to the \ref concepts::Graph + /// "Graph concept". class GridGraph : public ExtendedGridGraphBase { typedef ExtendedGridGraphBase Parent; @@ -509,9 +504,7 @@ public: - /// \brief Map to get the indices of the nodes as \ref dim2::Point - /// "dim2::Point". - /// - /// Map to get the indices of the nodes as \ref dim2::Point - /// "dim2::Point". + /// \brief Map to get the indices of the nodes as dim2::Point. + /// + /// Map to get the indices of the nodes as dim2::Point. class IndexMap { public: @@ -522,7 +515,11 @@ /// \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); @@ -544,7 +541,11 @@ /// \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,7 +567,11 @@ /// \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); @@ -579,12 +584,13 @@ /// \brief Constructor /// - /// Construct a grid graph with the given size. + /// Construct a grid graph with given size. GridGraph(int width, int height) { construct(width, height); } - /// \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. + /// \brief Resize 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. void resize(int width, int height) { Parent::notifier(Arc()).clear(); @@ -604,5 +610,5 @@ } - /// \brief The column index of the node. + /// \brief Gives back the column index of the node. /// /// Gives back the column index of the node. @@ -611,5 +617,5 @@ } - /// \brief The row index of the node. + /// \brief Gives back the row index of the node. /// /// Gives back the row index of the node. @@ -618,5 +624,5 @@ } - /// \brief The position of the node. + /// \brief Gives back the position of the node. /// /// Gives back the position of the node, ie. the (col,row) pair. @@ -625,5 +631,5 @@ } - /// \brief The number of the columns. + /// \brief Gives back the number of the columns. /// /// Gives back the number of the columns. @@ -632,5 +638,5 @@ } - /// \brief The number of the rows. + /// \brief Gives back the number of the rows. /// /// Gives back the number of the rows. @@ -639,5 +645,5 @@ } - /// \brief The arc goes right from the node. + /// \brief Gives back the arc goes right from the node. /// /// Gives back the arc goes right from the node. If there is not @@ -647,5 +653,5 @@ } - /// \brief The arc goes left from the node. + /// \brief Gives back the arc goes left from the node. /// /// Gives back the arc goes left from the node. If there is not @@ -655,5 +661,5 @@ } - /// \brief The arc goes up from the node. + /// \brief Gives back the arc goes up from the node. /// /// Gives back the arc goes up from the node. If there is not @@ -663,5 +669,5 @@ } - /// \brief The arc goes down from the node. + /// \brief Gives back the arc goes down from the node. /// /// Gives back the arc goes down from the node. If there is not Index: lemon/hypercube_graph.h =================================================================== --- lemon/hypercube_graph.h (revision 737) +++ lemon/hypercube_graph.h (revision 617) @@ -283,19 +283,15 @@ /// \brief Hypercube graph class /// - /// HypercubeGraph implements a special graph type. The nodes of the - /// graph are indexed with integers having at most \c dim binary digits. + /// This class implements a special graph type. The nodes of the graph + /// are indiced with integers with 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; @@ -307,19 +303,4 @@ /// 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. @@ -340,5 +321,5 @@ /// /// Gives back the dimension id of the given edge. - /// It is in the range [0..dim-1]. + /// It is in the [0..dim-1] range. int dimension(Edge edge) const { return Parent::dimension(edge); @@ -348,5 +329,5 @@ /// /// Gives back the dimension id of the given arc. - /// It is in the range [0..dim-1]. + /// It is in the [0..dim-1] range. int dimension(Arc arc) const { return Parent::dimension(arc); Index: mon/kary_heap.h =================================================================== --- lemon/kary_heap.h (revision 706) +++ (revision ) @@ -1,352 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_KARY_HEAP_H -#define LEMON_KARY_HEAP_H - -///\ingroup heaps -///\file -///\brief Fourary heap implementation. - -#include -#include -#include - -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 K=2 and K=4, 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. - /// - ///\sa BinHeap - ///\sa FouraryHeap -#ifdef DOXYGEN - template -#else - template > -#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 Pair; - /// Functor type for comparing the priorities. - typedef CMP Compare; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - std::vector _data; - Compare _comp; - ItemIntMap &_iim; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit 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 (-1) 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; i0) bubbleDown(0, _data[n], n); - _data.pop_back(); - } - - /// \brief Remove the given item from the heap. - /// - /// This function removes the given item from the heap if it is - /// already stored. - /// \param i The item to delete. - /// \pre \e i must be in the heap. - void erase(const Item &i) { - int h = _iim[i]; - int n = _data.size()-1; - _iim.set(_data[h].first, POST_HEAP); - if( h=0) s=0; - return State(s); - } - - /// \brief Set the state of an item in the heap. - /// - /// This function sets the state of the given item in the heap. - /// It can be used to manually clear the heap when it is important - /// to achive better time complexity. - /// \param i The item. - /// \param st The state. It should not be \c IN_HEAP. - void state(const Item& i, State st) { - switch (st) { - case POST_HEAP: - case PRE_HEAP: - if (state(i) == IN_HEAP) erase(i); - _iim[i] = st; - break; - case IN_HEAP: - break; - } - } - - /// \brief Replace an item in the heap. - /// - /// This function replaces item \c i with item \c j. - /// Item \c i must be in the heap, while \c j must be out of the heap. - /// After calling this method, item \c i will be out of the - /// heap and \c j will be in the heap with the same prioriority - /// as item \c i had before. - void replace(const Item& i, const Item& j) { - int idx=_iim[i]; - _iim.set(i, _iim[j]); - _iim.set(j, idx); - _data[idx].first=j; - } - - }; // class KaryHeap - -} // namespace lemon - -#endif // LEMON_KARY_HEAP_H Index: lemon/list_graph.h =================================================================== --- lemon/list_graph.h (revision 741) +++ lemon/list_graph.h (revision 617) @@ -22,5 +22,5 @@ ///\ingroup graphs ///\file -///\brief ListDigraph and ListGraph classes. +///\brief ListDigraph, ListGraph classes. #include @@ -32,6 +32,4 @@ namespace lemon { - - class ListDigraph; class ListDigraphBase { @@ -65,5 +63,4 @@ class Node { friend class ListDigraphBase; - friend class ListDigraph; protected: @@ -81,5 +78,4 @@ class Arc { friend class ListDigraphBase; - friend class ListDigraph; protected: @@ -121,18 +117,18 @@ int n; for(n = first_node; - n != -1 && nodes[n].first_out == -1; + n!=-1 && nodes[n].first_in == -1; n = nodes[n].next) {} - arc.id = (n == -1) ? -1 : nodes[n].first_out; + arc.id = (n == -1) ? -1 : nodes[n].first_in; } void next(Arc& arc) const { - if (arcs[arc.id].next_out != -1) { - arc.id = arcs[arc.id].next_out; + if (arcs[arc.id].next_in != -1) { + arc.id = arcs[arc.id].next_in; } else { int n; - for(n = nodes[arcs[arc.id].source].next; - n != -1 && nodes[n].first_out == -1; + for(n = nodes[arcs[arc.id].target].next; + n!=-1 && nodes[n].first_in == -1; n = nodes[n].next) {} - arc.id = (n == -1) ? -1 : nodes[n].first_out; + arc.id = (n == -1) ? -1 : nodes[n].first_in; } } @@ -316,23 +312,29 @@ ///A general directed graph structure. - ///\ref ListDigraph is a versatile and fast directed graph - ///implementation based on linked lists that are stored in + ///\ref ListDigraph is a simple and fast directed graph + ///implementation based on static linked lists that are stored in ///\c std::vector structures. /// - ///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 + ///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 ///only in the concept class. /// ///\sa concepts::Digraph - ///\sa ListGraph + class ListDigraph : public ExtendedListDigraphBase { typedef ExtendedListDigraphBase Parent; private: - /// Digraphs are \e not copy constructible. Use DigraphCopy instead. + ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. + + ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. + /// ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {}; - /// \brief Assignment of a digraph to another one is \e not allowed. - /// Use DigraphCopy instead. + ///\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. void operator=(const ListDigraph &) {} public: @@ -346,5 +348,5 @@ ///Add a new node to the digraph. - ///This function adds a new node to the digraph. + ///Add a new node to the digraph. ///\return The new node. Node addNode() { return Parent::addNode(); } @@ -352,8 +354,8 @@ ///Add a new arc to the digraph. - ///This function adds a new arc to the digraph with source node \c s + ///Add a new arc to the digraph with source node \c s ///and target node \c t. ///\return The new arc. - Arc addArc(Node s, Node t) { + Arc addArc(const Node& s, const Node& t) { return Parent::addArc(s, t); } @@ -361,36 +363,41 @@ ///\brief Erase a node from the digraph. /// - ///This function erases the given node from the digraph. - void erase(Node n) { Parent::erase(n); } + ///Erase a node from the digraph. + /// + void erase(const Node& n) { Parent::erase(n); } ///\brief Erase an arc from the digraph. /// - ///This function erases the given arc from the digraph. - void erase(Arc a) { Parent::erase(a); } + ///Erase an arc from the digraph. + /// + void erase(const Arc& a) { Parent::erase(a); } /// Node validity check - /// 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 could become valid again if new nodes are - /// added to the digraph. + /// This function gives back true if the given node is valid, + /// ie. 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 + /// added to the graph. bool valid(Node n) const { return Parent::valid(n); } /// Arc validity check - /// 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 could become valid again if new arcs are - /// added to the digraph. + /// This function gives back true if the given arc is valid, + /// ie. it is a real arc of the graph. + /// + /// \warning An Arc pointing to a removed item + /// could become valid again later if new nodes are + /// added to the graph. bool valid(Arc a) const { return Parent::valid(a); } - /// Change the target node of an arc - - /// This function changes the target node of the given arc \c a to \c n. - /// - ///\note \c ArcIt and \c OutArcIt iterators referencing the changed - ///arc remain valid, however \c InArcIt iterators are invalidated. + /// Change the target of \c a to \c n + + /// Change the target of \c a to \c n + /// + ///\note The ArcIts and OutArcIts referencing + ///the changed arc remain valid. However InArcIts are + ///invalidated. /// ///\warning This functionality cannot be used together with the Snapshot @@ -399,10 +406,11 @@ Parent::changeTarget(a,n); } - /// Change the source node of an arc - - /// This function changes the source node of the given arc \c a to \c n. - /// - ///\note \c InArcIt iterators referencing the changed arc remain - ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated. + /// Change the source of \c a to \c n + + /// Change the source of \c a to \c n + /// + ///\note The InArcIts referencing the changed arc remain + ///valid. However the ArcIts and OutArcIts are + ///invalidated. /// ///\warning This functionality cannot be used together with the Snapshot @@ -412,74 +420,92 @@ } - /// Reverse the direction of an arc. - - /// This function reverses the direction of the given arc. - ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing - ///the changed arc are invalidated. + /// Invert the direction of an arc. + + ///\note The ArcIts referencing the changed arc remain + ///valid. However OutArcIts and InArcIts are + ///invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. - void reverseArc(Arc a) { - Node t=target(a); - changeTarget(a,source(a)); - changeSource(a,t); - } + void reverseArc(Arc e) { + Node t=target(e); + changeTarget(e,source(e)); + changeSource(e,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 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 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. + ///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. + /// + ///\note The ArcIts referencing a moved arc remain + ///valid. However InArcIts and OutArcIts + ///may be invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///feature. - void contract(Node u, Node v, bool r = true) + void contract(Node a, Node b, bool r = true) { - for(OutArcIt e(*this,v);e!=INVALID;) { + for(OutArcIt e(*this,b);e!=INVALID;) { OutArcIt f=e; ++f; - if(r && target(e)==u) erase(e); - else changeSource(e,u); + if(r && target(e)==a) erase(e); + else changeSource(e,a); e=f; } - for(InArcIt e(*this,v);e!=INVALID;) { + for(InArcIt e(*this,b);e!=INVALID;) { InArcIt f=e; ++f; - if(r && source(e)==u) erase(e); - else changeTarget(e,u); + if(r && source(e)==a) erase(e); + else changeTarget(e,a); e=f; } - erase(v); + erase(b); } ///Split a node. - ///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. + ///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. ///\return The newly created node. /// - ///\note All iterators remain valid. - /// - ///\warning This functionality cannot be used together with the + ///\note The ArcIts referencing a moved arc remain + ///valid. However InArcIts and OutArcIts may + ///be invalidated. + /// + ///\warning This functionality cannot be used in conjunction with the ///Snapshot feature. Node split(Node n, bool connect = true) { Node b = addNode(); - 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; + for(OutArcIt e(*this,n);e!=INVALID;) { + OutArcIt f=e; + ++f; + changeSource(e,b); + e=f; } if (connect) addArc(n,b); @@ -489,49 +515,18 @@ ///Split an arc. - ///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. + ///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. + /// ///\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 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); }; + Node split(Arc e) { + Node b = addNode(); + addArc(b,target(e)); + changeTarget(e,b); + return b; + } /// \brief Class to make a snapshot of the digraph and restore @@ -543,13 +538,7 @@ /// restore() function. /// - /// \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 + /// \warning Arc and node deletions and other modifications (e.g. + /// contracting, splitting, reversing 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: @@ -721,5 +710,5 @@ /// /// Default constructor. - /// You have to call save() to actually make a snapshot. + /// To actually make a snapshot you must call save(). Snapshot() : digraph(0), node_observer_proxy(*this), @@ -728,31 +717,30 @@ /// \brief Constructor that immediately makes a snapshot. /// - /// This constructor immediately makes a snapshot of the given digraph. - Snapshot(ListDigraph &gr) + /// This constructor immediately makes a snapshot of the digraph. + /// \param _digraph The digraph we make a snapshot of. + Snapshot(ListDigraph &_digraph) : node_observer_proxy(*this), arc_observer_proxy(*this) { - attach(gr); + attach(_digraph); } /// \brief Make a snapshot. /// - /// This function makes a snapshot of the given digraph. - /// It can be called more than once. In case of a repeated + /// Make a snapshot of the digraph. + /// + /// This function can be called more than once. In case of a repeated /// call, the previous snapshot gets lost. - void save(ListDigraph &gr) { + /// \param _digraph The digraph we make the snapshot of. + void save(ListDigraph &_digraph) { if (attached()) { detach(); clear(); } - attach(gr); + attach(_digraph); } /// \brief Undo the changes until the last snapshot. - /// - /// 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. + // + /// Undo the changes until the last snapshot created by save(). void restore() { detach(); @@ -768,7 +756,7 @@ } - /// \brief Returns \c true if the snapshot is valid. + /// \brief Gives back true when the snapshot is valid. /// - /// This function returns \c true if the snapshot is valid. + /// Gives back true when the snapshot is valid. bool valid() const { return attached(); @@ -807,4 +795,8 @@ typedef ListGraphBase Graph; + + class Node; + class Arc; + class Edge; class Node { @@ -856,4 +848,6 @@ bool operator<(const Arc& arc) const {return id < arc.id;} }; + + ListGraphBase() @@ -1171,23 +1165,29 @@ ///A general undirected graph structure. - ///\ref ListGraph is a versatile and fast undirected graph - ///implementation based on linked lists that are stored in + ///\ref ListGraph is a simple and fast undirected graph + ///implementation based on static linked lists that are stored in ///\c std::vector structures. /// - ///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 + ///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 ///only in the concept class. /// ///\sa concepts::Graph - ///\sa ListDigraph + class ListGraph : public ExtendedListGraphBase { typedef ExtendedListGraphBase Parent; private: - /// Graphs are \e not copy constructible. Use GraphCopy instead. + ///ListGraph is \e not copy constructible. Use copyGraph() instead. + + ///ListGraph is \e not copy constructible. Use copyGraph() instead. + /// ListGraph(const ListGraph &) :ExtendedListGraphBase() {}; - /// \brief Assignment of a graph to another one is \e not allowed. - /// Use GraphCopy instead. + ///\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. void operator=(const ListGraph &) {} public: @@ -1202,5 +1202,5 @@ /// \brief Add a new node to the graph. /// - /// This function adds a new node to the graph. + /// Add a new node to the graph. /// \return The new node. Node addNode() { return Parent::addNode(); } @@ -1208,53 +1208,57 @@ /// \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. + /// Add a new edge to the graph with source node \c s + /// and target node \c t. /// \return The new edge. - Edge addEdge(Node u, Node v) { - return Parent::addEdge(u, v); - } - - ///\brief 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. - /// - /// This function erases the given edge from the graph. - void erase(Edge e) { Parent::erase(e); } + Edge addEdge(const Node& s, const Node& t) { + return Parent::addEdge(s, t); + } + + /// \brief Erase a node from the graph. + /// + /// Erase a node 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); } /// Node validity check - /// 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 could become valid again if new nodes are + /// This function gives back true if the given node is valid, + /// ie. 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 /// added to the graph. 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. + /// + /// \warning An Arc pointing to a removed item + /// could become valid again later if new edges are + /// added to the graph. + bool valid(Arc a) const { return Parent::valid(a); } /// 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 + /// This function gives back true if the given edge is valid, + /// ie. it is a real arc of the graph. + /// + /// \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); } - /// Arc validity check - - /// 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 could become valid again if new edges are - /// added to the graph. - bool valid(Arc a) const { return Parent::valid(a); } - - /// \brief Change the first node of an edge. - /// - /// This function changes the first node of the given edge \c e to \c n. - /// - ///\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. + /// \brief Change the end \c u of \c e to \c n + /// + /// This function changes the end \c u of \c e to node \c n. + /// + ///\note The EdgeIts and ArcIts referencing the + ///changed edge are invalidated and if the changed node is the + ///base node of an iterator then this iterator is also + ///invalidated. /// ///\warning This functionality cannot be used together with the @@ -1263,12 +1267,11 @@ Parent::changeU(e,n); } - /// \brief Change the second node of an edge. - /// - /// This function changes the second node of the given edge \c e to \c n. - /// - ///\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. + /// \brief Change the end \c v of \c e to \c n + /// + /// This function changes the end \c v of \c e to \c n. + /// + ///\note The EdgeIts referencing the changed edge remain + ///valid, however ArcIts and if the changed node is the + ///base node of an iterator then this iterator is invalidated. /// ///\warning This functionality cannot be used together with the @@ -1277,18 +1280,14 @@ Parent::changeV(e,n); } - /// \brief Contract two nodes. /// - /// 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 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. + /// 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. + /// + /// \note The ArcIts referencing a moved arc remain + /// valid. /// ///\warning This functionality cannot be used together with the @@ -1309,31 +1308,4 @@ } - ///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 @@ -1345,13 +1317,7 @@ /// using the restore() function. /// - /// \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. + /// \warning Edge and node deletions and other modifications + /// (e.g. changing nodes of edges, contracting nodes) cannot be + /// restored. These events invalidate the snapshot. class Snapshot { protected: @@ -1523,5 +1489,5 @@ /// /// Default constructor. - /// You have to call save() to actually make a snapshot. + /// To actually make a snapshot you must call save(). Snapshot() : graph(0), node_observer_proxy(*this), @@ -1530,31 +1496,30 @@ /// \brief Constructor that immediately makes a snapshot. /// - /// This constructor immediately makes a snapshot of the given graph. - Snapshot(ListGraph &gr) + /// This constructor immediately makes a snapshot of the graph. + /// \param _graph The graph we make a snapshot of. + Snapshot(ListGraph &_graph) : node_observer_proxy(*this), edge_observer_proxy(*this) { - attach(gr); + attach(_graph); } /// \brief Make a snapshot. /// - /// This function makes a snapshot of the given graph. - /// It can be called more than once. In case of a repeated + /// Make a snapshot of the graph. + /// + /// This function can be called more than once. In case of a repeated /// call, the previous snapshot gets lost. - void save(ListGraph &gr) { + /// \param _graph The graph we make the snapshot of. + void save(ListGraph &_graph) { if (attached()) { detach(); clear(); } - attach(gr); + attach(_graph); } /// \brief Undo the changes until the last snapshot. - /// - /// 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. + // + /// Undo the changes until the last snapshot created by save(). void restore() { detach(); @@ -1570,7 +1535,7 @@ } - /// \brief Returns \c true if the snapshot is valid. + /// \brief Gives back true when the snapshot is valid. /// - /// This function returns \c true if the snapshot is valid. + /// Gives back true when the snapshot is valid. bool valid() const { return attached(); Index: lemon/lp_base.h =================================================================== --- lemon/lp_base.h (revision 746) +++ lemon/lp_base.h (revision 584) @@ -944,12 +944,4 @@ 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; @@ -1216,8 +1208,6 @@ ///\return The created row. Row addRow(Value l,const Expr &e, Value u) { - Row r; - e.simplify(); - r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols), - ExprIterator(e.comps.end(), cols), u - *e)); + Row r=addRow(); + row(r,l,e,u); return r; } @@ -1228,10 +1218,6 @@ ///\return The created row. Row addRow(const Constr &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)); + Row r=addRow(); + row(r,c); return r; } Index: lemon/lp_skeleton.cc =================================================================== --- lemon/lp_skeleton.cc (revision 746) +++ lemon/lp_skeleton.cc (revision 576) @@ -29,9 +29,4 @@ int SkeletonSolverBase::_addRow() - { - return ++row_num; - } - - int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value) { return ++row_num; Index: lemon/lp_skeleton.h =================================================================== --- lemon/lp_skeleton.h (revision 746) +++ lemon/lp_skeleton.h (revision 576) @@ -45,6 +45,4 @@ /// \e virtual int _addRow(); - /// \e - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); /// \e virtual void _eraseCol(int i); Index: lemon/maps.h =================================================================== --- lemon/maps.h (revision 726) +++ lemon/maps.h (revision 617) @@ -23,5 +23,4 @@ #include #include -#include #include @@ -30,4 +29,6 @@ ///\ingroup maps ///\brief Miscellaneous property maps + +#include namespace lemon { @@ -57,5 +58,5 @@ /// but data written to it is not required (i.e. it will be sent to /// /dev/null). - /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. + /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept. /// /// \sa ConstMap @@ -90,5 +91,5 @@ /// /// In other aspects it is equivalent to \c NullMap. - /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" + /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept, but it absorbs the data written to it. /// @@ -159,5 +160,5 @@ /// /// In other aspects it is equivalent to \c NullMap. - /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" + /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" /// concept, but it absorbs the data written to it. /// @@ -233,5 +234,5 @@ /// It can be used with some data structures, for example /// \c UnionFind, \c BinHeap, when the used items are small - /// integers. This map conforms to the \ref concepts::ReferenceMap + /// integers. This map conforms the \ref concepts::ReferenceMap /// "ReferenceMap" concept. /// @@ -341,5 +342,5 @@ /// stored actually. This value can be different from the default /// contructed value (i.e. \c %Value()). - /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap" + /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap" /// concept. /// @@ -707,5 +708,5 @@ /// The \c Key type of it is inherited from \c M and the \c Value /// type is \c V. - /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. + /// This type conforms the \ref concepts::ReadMap "ReadMap" concept. /// /// The simplest way of using this map is through the convertMap() @@ -1790,9 +1791,9 @@ /// \code /// std::vector v; - /// dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s); + /// dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run(); /// \endcode /// \code /// std::vector v(countNodes(g)); - /// dfs(g).processedMap(loggerBoolMap(v.begin())).run(s); + /// dfs(g,s).processedMap(loggerBoolMap(v.begin())).run(); /// \endcode /// @@ -1818,5 +1819,5 @@ /// /// 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 @@ -1826,5 +1827,5 @@ /// 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. @@ -1866,9 +1867,7 @@ public: - /// \brief The inverse map type of 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. + /// \brief This class represents the inverse of its owner (IdMap). + /// + /// This class represents the inverse of its owner (IdMap). /// \see inverse() class InverseMap { @@ -1885,7 +1884,7 @@ explicit InverseMap(const IdMap& map) : _graph(map._graph) {} - /// \brief Gives back an item by its id. + /// \brief Gives back the given item from its id. /// - /// Gives back an item by its id. + /// Gives back the given item from its id. Item operator[](int id) const { return _graph->fromId(id, Item());} @@ -1900,32 +1899,14 @@ }; - /// \brief Returns an \c IdMap class. - /// - /// This function just returns an \c IdMap class. - /// \relates IdMap - template - inline IdMap idMap(const GR& graph) { - return IdMap(graph); - } /// \brief General cross reference graph map type. /// This class provides simple invertable graph maps. - /// 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. - /// - /// This type is not reference map, so it cannot be modified with - /// the subscript operator. + /// 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. + /// + /// The values of the map can be accessed + /// with stl compatible forward iterator. /// /// \tparam GR The graph type. @@ -1943,5 +1924,5 @@ template Map::Type Map; - typedef std::multimap Container; + typedef std::map Container; Container _inv_map; @@ -1965,64 +1946,52 @@ /// \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 [beginValue, endValue) range. - /// They are considered with multiplicity, so each value is - /// traversed for each item it is assigned to. - class ValueIt + class ValueIterator : public std::iterator { friend class CrossRefMap; private: - ValueIt(typename Container::const_iterator _it) + ValueIterator(typename Container::const_iterator _it) : it(_it) {} public: - /// Constructor - ValueIt() {} - - /// \e - ValueIt& operator++() { ++it; return *this; } - /// \e - ValueIt operator++(int) { - ValueIt tmp(*this); + ValueIterator() {} + + ValueIterator& operator++() { ++it; return *this; } + ValueIterator operator++(int) { + ValueIterator 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; } + bool operator==(ValueIterator jt) const { return it == jt.it; } + bool operator!=(ValueIterator 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 [beginValue, endValue) /// range. - ValueIt beginValue() const { - return ValueIt(_inv_map.begin()); + ValueIterator beginValue() const { + return ValueIterator(_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 [beginValue, endValue) /// range. - ValueIt endValue() const { - return ValueIt(_inv_map.end()); + ValueIterator endValue() const { + return ValueIterator(_inv_map.end()); } @@ -2032,13 +2001,9 @@ void set(const Key& key, const Value& val) { Value oldval = Map::operator[](key); - 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; - } + typename Container::iterator it = _inv_map.find(oldval); + if (it != _inv_map.end() && it->second == key) { + _inv_map.erase(it); } - _inv_map.insert(std::make_pair(val, key)); + _inv_map.insert(make_pair(val, key)); Map::set(key, val); } @@ -2052,21 +2017,10 @@ } - /// \brief Gives back an item by its value. - /// - /// 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); + /// \brief Gives back the 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); 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); } @@ -2079,11 +2033,7 @@ virtual void erase(const Key& key) { Value val = Map::operator[](key); - 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; - } + typename Container::iterator it = _inv_map.find(val); + if (it != _inv_map.end() && it->second == key) { + _inv_map.erase(it); } Map::erase(key); @@ -2097,11 +2047,7 @@ for (int i = 0; i < int(keys.size()); ++i) { Value val = Map::operator[](keys[i]); - 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; - } + typename Container::iterator it = _inv_map.find(val); + if (it != _inv_map.end() && it->second == keys[i]) { + _inv_map.erase(it); } } @@ -2120,10 +2066,8 @@ public: - /// \brief The inverse map type of CrossRefMap. - /// - /// 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() + /// \brief The inverse map type. + /// + /// The inverse of this map. The subscript operator of the map + /// gives back the item that was last assigned to the value. class InverseMap { public: @@ -2141,7 +2085,6 @@ /// \brief Subscript operator. /// - /// Subscript operator. It gives back an item - /// that is assigned to the given value or \c INVALID - /// if no such item exists. + /// Subscript operator. It gives back the item + /// that was last assigned to the given value. Value operator[](const Key& key) const { return _inverted(key); @@ -2152,7 +2095,7 @@ }; - /// \brief Gives back the inverse of the map. - /// - /// Gives back the inverse of the CrossRefMap. + /// \brief It gives back the read-only inverse map. + /// + /// It gives back the read-only inverse map. InverseMap inverse() const { return InverseMap(*this); @@ -2161,9 +2104,9 @@ }; - /// \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, @@ -2176,5 +2119,5 @@ /// 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. @@ -2304,14 +2247,14 @@ } - /// \brief Gives back the \e range \e id of the item - /// - /// Gives back the \e range \e id of the item. + /// \brief Gives back the \e RangeId of the item + /// + /// Gives back the \e RangeId of the item. int operator[](const Item& item) const { return Map::operator[](item); } - /// \brief Gives back the item belonging to a \e range \e id - /// - /// Gives back the item belonging to the given \e range \e id. + /// \brief Gives back the item belonging to a \e RangeId + /// + /// Gives back the item belonging to a \e RangeId. Item operator()(int id) const { return _inv_map[id]; @@ -2327,7 +2270,5 @@ /// \brief 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. + /// The inverse map type of RangeIdMap. class InverseMap { public: @@ -2347,5 +2288,5 @@ /// /// Subscript operator. It gives back the item - /// that the given \e range \e id currently belongs to. + /// that the descriptor currently belongs to. Value operator[](const Key& key) const { return _inverted(key); @@ -2365,928 +2306,8 @@ /// \brief Gives back the inverse of the map. /// - /// Gives back the inverse of the RangeIdMap. + /// Gives back the inverse of the map. const InverseMap inverse() const { return InverseMap(*this); } - }; - - /// \brief Returns a \c RangeIdMap class. - /// - /// This function just returns an \c RangeIdMap class. - /// \relates RangeIdMap - template - inline RangeIdMap rangeIdMap(const GR& graph) { - return RangeIdMap(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 - class IterableBoolMap - : protected ItemSetTraits::template Map::Type { - private: - typedef GR Graph; - - typedef typename ItemSetTraits::ItemIt KeyIt; - typedef typename ItemSetTraits::template Map::Type Parent; - - std::vector _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(value)); - return *this; - } - - operator bool() const { - return static_cast(_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& 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& 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 - 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 - class IterableIntMap - : protected ItemSetTraits:: - template Map<_maps_bits::IterableIntMapNode >::Type { - public: - typedef typename ItemSetTraits:: - template Map<_maps_bits::IterableIntMapNode >::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(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(value)); - return *this; - } - - operator const int&() const { - return static_cast(_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(*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& 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 _first; - }; - - namespace _maps_bits { - template - 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 - class IterableValueMap - : protected ItemSetTraits:: - template Map<_maps_bits::IterableValueMapNode >::Type { - public: - typedef typename ItemSetTraits:: - template Map<_maps_bits::IterableValueMapNode >::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(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::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 [beginValue, endValue) range. - class ValueIt - : public std::iterator { - friend class IterableValueMap; - private: - ValueIt(typename std::map::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::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 [beginValue, endValue) - /// 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 [beginValue, endValue) - /// 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::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(*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& 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& 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 _first; }; @@ -3301,7 +2322,7 @@ public: - /// The key type (the \c Arc type of the digraph). + ///\e typedef typename GR::Arc Key; - /// The value type (the \c Node type of the digraph). + ///\e typedef typename GR::Node Value; @@ -3342,7 +2363,7 @@ public: - /// The key type (the \c Arc type of the digraph). + ///\e typedef typename GR::Arc Key; - /// The value type (the \c Node type of the digraph). + ///\e typedef typename GR::Node Value; @@ -3384,8 +2405,6 @@ public: - /// The key type (the \c Edge type of the digraph). + typedef typename GR::Arc Value; typedef typename GR::Edge Key; - /// The value type (the \c Arc type of the digraph). - typedef typename GR::Arc Value; /// \brief Constructor @@ -3426,8 +2445,6 @@ public: - /// The key type (the \c Edge type of the digraph). + typedef typename GR::Arc Value; typedef typename GR::Edge Key; - /// The value type (the \c Arc type of the digraph). - typedef typename GR::Arc Value; /// \brief Constructor @@ -3464,5 +2481,5 @@ /// 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 @@ -3480,5 +2497,5 @@ public: - + /// The graph type of InDegMap typedef GR Graph; @@ -3594,5 +2611,5 @@ /// 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 Index: lemon/min_cost_arborescence.h =================================================================== --- lemon/min_cost_arborescence.h (revision 713) +++ lemon/min_cost_arborescence.h (revision 625) @@ -489,6 +489,6 @@ /// The simplest way to execute the algorithm is to use /// one of the member functions called \c run(...). \n - /// If you need better control on the execution, - /// you have to call \ref init() first, then you can add several + /// If you need more control on the execution, + /// first you must call \ref init(), then you can add several /// source nodes with \ref addSource(). /// Finally \ref start() will perform the arborescence Index: lemon/network_simplex.h =================================================================== --- lemon/network_simplex.h (revision 730) +++ lemon/network_simplex.h (revision 663) @@ -162,4 +162,6 @@ TEMPLATE_DIGRAPH_TYPEDEFS(GR); + typedef std::vector ArcVector; + typedef std::vector NodeVector; typedef std::vector IntVector; typedef std::vector BoolVector; @@ -363,30 +365,31 @@ Cost c, min = 0; int cnt = _block_size; - int e; + int e, min_arc = _next_arc; 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; - _in_arc = e; + min_arc = e; } if (--cnt == 0) { - if (min < 0) goto search_end; + 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 || 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; + } } } if (min >= 0) return false; - - search_end: + _in_arc = min_arc; _next_arc = e; return true; @@ -426,5 +429,5 @@ { // The main parameters of the pivot rule - const double LIST_LENGTH_FACTOR = 0.25; + const double LIST_LENGTH_FACTOR = 1.0; const int MIN_LIST_LENGTH = 10; const double MINOR_LIMIT_FACTOR = 0.1; @@ -443,5 +446,5 @@ bool findEnteringArc() { Cost min, c; - int e; + int e, min_arc = _next_arc; if (_curr_length > 0 && _minor_count < _minor_limit) { // Minor iteration: select the best eligible arc from the @@ -454,11 +457,14 @@ if (c < min) { min = c; - _in_arc = e; + min_arc = e; } - else if (c >= 0) { + if (c >= 0) { _candidates[i--] = _candidates[--_curr_length]; } } - if (min < 0) return true; + if (min < 0) { + _in_arc = min_arc; + return true; + } } @@ -472,24 +478,25 @@ if (c < min) { min = c; - _in_arc = e; + min_arc = e; } - if (_curr_length == _list_length) goto search_end; - } - } - 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) break; + } + } + 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; } - 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; @@ -543,5 +550,5 @@ { // The main parameters of the pivot rule - const double BLOCK_SIZE_FACTOR = 1.0; + const double BLOCK_SIZE_FACTOR = 1.5; const int MIN_BLOCK_SIZE = 10; const double HEAD_LENGTH_FACTOR = 0.1; @@ -572,33 +579,37 @@ // Extend the list int cnt = _block_size; + int last_arc = 0; int limit = _head_length; - for (e = _next_arc; e < _search_arc_num; ++e) { + for (int 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) goto search_end; + 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 <= 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; + } } } if (_curr_length == 0) return false; - - search_end: + _next_arc = last_arc + 1; // Make heap of the candidate list (approximating a partial sort) @@ -608,5 +619,4 @@ // Pop the first element of the heap _in_arc = _candidates[0]; - _next_arc = e; pop_heap( _candidates.begin(), _candidates.begin() + _curr_length, _sort_func ); @@ -624,9 +634,5 @@ /// /// \param graph The digraph the algorithm runs on. - /// \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) : + NetworkSimplex(const GR& graph) : _graph(graph), _node_id(graph), _arc_id(graph), INF(std::numeric_limits::has_infinity ? @@ -666,31 +672,29 @@ _state.resize(max_arc_num); - // Copy the graph + // Copy the graph (store the arcs in a mixed order) int i = 0; for (NodeIt n(_graph); n != INVALID; ++n, ++i) { _node_id[n] = i; } - 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)]; - } + 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; } - // Reset parameters - reset(); + // 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; } @@ -765,4 +769,5 @@ /// 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. @@ -785,4 +790,5 @@ /// 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() Index: mon/pairing_heap.h =================================================================== --- lemon/pairing_heap.h (revision 705) +++ (revision ) @@ -1,474 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_PAIRING_HEAP_H -#define LEMON_PAIRING_HEAP_H - -///\file -///\ingroup heaps -///\brief Pairing heap implementation. - -#include -#include -#include -#include - -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. -#ifdef DOXYGEN - template -#else - template > -#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 (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - class store; - - std::vector _data; - int _min; - ItemIntMap &_iim; - Compare _comp; - int _num_items; - - public: - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - explicit 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 (-1) 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 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=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 - Index: lemon/path.h =================================================================== --- lemon/path.h (revision 751) +++ lemon/path.h (revision 559) @@ -1016,18 +1016,16 @@ /// \brief The source of a path /// - /// This function returns the source node of the given path. - /// If the path is empty, then it returns \c INVALID. + /// This function returns the source of the given path. template typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) { - return path.empty() ? INVALID : digraph.source(path.front()); + return digraph.source(path.front()); } /// \brief The target of a path /// - /// This function returns the target node of the given path. - /// If the path is empty, then it returns \c INVALID. + /// This function returns the target of the given path. template typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) { - return path.empty() ? INVALID : digraph.target(path.back()); + return digraph.target(path.back()); } Index: lemon/preflow.h =================================================================== --- lemon/preflow.h (revision 715) +++ lemon/preflow.h (revision 688) @@ -53,9 +53,5 @@ /// The type of the map that stores the flow values. /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. -#ifdef DOXYGEN - typedef GR::ArcMap FlowMap; -#else typedef typename Digraph::template ArcMap FlowMap; -#endif /// \brief Instantiates a FlowMap. @@ -72,10 +68,7 @@ /// The elevator type used by Preflow algorithm. /// - /// \sa Elevator, LinkedElevator -#ifdef DOXYGEN - typedef lemon::Elevator Elevator; -#else - typedef lemon::Elevator Elevator; -#endif + /// \sa Elevator + /// \sa LinkedElevator + typedef LinkedElevator Elevator; /// \brief Instantiates an Elevator. @@ -105,5 +98,5 @@ /// "flow of maximum value" in a digraph. /// The preflow algorithms are the fastest known maximum - /// flow algorithms. The current implementation uses a mixture of the + /// flow algorithms. The current implementation use 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$. @@ -379,8 +372,7 @@ } - /// \brief Sets the tolerance used by the algorithm. - /// - /// Sets the tolerance object used by the algorithm. - /// \return (*this) + /// \brief Sets the tolerance used by algorithm. + /// + /// Sets the tolerance used by algorithm. Preflow& tolerance(const Tolerance& tolerance) { _tolerance = tolerance; @@ -390,6 +382,5 @@ /// \brief Returns a const reference to the tolerance. /// - /// Returns a const reference to the tolerance object used by - /// the algorithm. + /// Returns a const reference to the tolerance. const Tolerance& tolerance() const { return _tolerance; @@ -399,6 +390,6 @@ /// The simplest way to execute the preflow algorithm is to use /// \ref run() or \ref runMinCut().\n - /// If you need better control on the initial solution or the execution, - /// you have to call one of the \ref init() functions first, then + /// If you need more control on the initial solution or the execution, + /// first you have to call one of the \ref init() functions, then /// \ref startFirstPhase() and if you need it \ref startSecondPhase(). Index: mon/radix_heap.h =================================================================== --- lemon/radix_heap.h (revision 711) +++ (revision ) @@ -1,438 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#ifndef LEMON_RADIX_HEAP_H -#define LEMON_RADIX_HEAP_H - -///\ingroup heaps -///\file -///\brief Radix heap implementation. - -#include -#include - -namespace lemon { - - - /// \ingroup heaps - /// - /// \brief Radix heap data structure. - /// - /// 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. - /// - /// \tparam IM A read-writable item map with \c int values, used - /// internally to handle the cross references. - template - class RadixHeap { - - public: - - /// Type of the item-int map. - typedef IM ItemIntMap; - /// Type of the priorities. - typedef int Prio; - /// Type of the items stored in the heap. - typedef typename ItemIntMap::Key Item; - - /// \brief Exception thrown by RadixHeap. - /// - /// This exception is thrown when an item is inserted into a - /// RadixHeap with a priority smaller than the last erased one. - /// \see RadixHeap - class PriorityUnderflowError : public Exception { - public: - virtual const char* what() const throw() { - return "lemon::RadixHeap::PriorityUnderflowError"; - } - }; - - /// \brief Type to represent the states of the items. - /// - /// Each item has a state associated to it. It can be "in heap", - /// "pre-heap" or "post-heap". The latter two are indifferent from the - /// heap's point of view, but may be useful to the user. - /// - /// The item-int map must be initialized in such way that it assigns - /// \c PRE_HEAP (-1) to any element to be put in the heap. - enum State { - IN_HEAP = 0, ///< = 0. - PRE_HEAP = -1, ///< = -1. - POST_HEAP = -2 ///< = -2. - }; - - private: - - struct RadixItem { - int prev, next, box; - Item item; - int prio; - RadixItem(Item _item, int _prio) : item(_item), prio(_prio) {} - }; - - struct RadixBox { - int first; - int min, size; - RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {} - }; - - std::vector _data; - std::vector _boxes; - - ItemIntMap &_iim; - - public: - - /// \brief Constructor. - /// - /// Constructor. - /// \param map A map that assigns \c int values to the items. - /// It is used internally to handle the cross references. - /// The assigned value must be \c PRE_HEAP (-1) for each item. - /// \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(); - } - } - - /// \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. - /// \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(); - } - } - - private: - - bool upper(int box, Prio pr) { - return pr < _boxes[box].min; - } - - bool lower(int box, Prio pr) { - return pr >= _boxes[box].min + _boxes[box].size; - } - - // Remove item from the box list - void remove(int index) { - if (_data[index].prev >= 0) { - _data[_data[index].prev].next = _data[index].next; - } else { - _boxes[_data[index].box].first = _data[index].next; - } - if (_data[index].next >= 0) { - _data[_data[index].next].prev = _data[index].prev; - } - } - - // 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; - } else { - _data[index].next = _boxes[box].first; - _data[_boxes[box].first].prev = index; - _data[index].prev = -1; - _boxes[box].first = index; - } - _data[index].box = box; - } - - // 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)); - } - - // 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); - insert(box, index); - } - - // 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())) { - extend(); - } - } - return start; - } - - // 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); - insert(box, index); - } - - // 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 PriorityUnderflowError(); - } - return start; - } - - // Find the first non-empty box - int findFirst() { - int first = 0; - while (_boxes[first].first == -1) ++first; - return first; - } - - // 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; - } - return min; - } - - // 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; - } - int curr = _boxes[box].first, next; - while (curr != -1) { - next = _data[curr].next; - bubbleDown(curr); - curr = next; - } - } - - 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; - } - if (_data[index].next != -1) { - _data[_data[index].next].prev = index; - } - _iim[_data[index].item] = index; - } - _data.pop_back(); - } - - public: - - /// \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. - /// \warning This method may throw an \c UnderFlowPriorityException. - void push(const Item &i, const Prio &p) { - int n = _data.size(); - _iim.set(i, n); - _data.push_back(RadixItem(i, p)); - while (lower(_boxes.size() - 1, p)) { - extend(); - } - int box = findDown(_boxes.size() - 1, p); - insert(box, n); - } - - /// \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 { - const_cast&>(*this).moveDown(); - return _data[_boxes[0].first].item; - } - - /// \brief The minimum priority. - /// - /// This function returns the minimum priority. - /// \pre The heap must be non-empty. - Prio prio() const { - const_cast&>(*this).moveDown(); - return _data[_boxes[0].first].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() { - moveDown(); - int index = _boxes[0].first; - _iim[_data[index].item] = POST_HEAP; - remove(index); - relocateLast(index); - } - - /// \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 index = _iim[i]; - _iim[i] = POST_HEAP; - remove(index); - relocateLast(index); - } - - /// \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].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 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; - bubbleUp(idx); - } else { - _data[idx].prio = p; - bubbleDown(idx); - } - } - - /// \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. - /// \warning This method may throw an \c UnderFlowPriorityException. - void decrease(const Item &i, const Prio &p) { - int idx = _iim[i]; - _data[idx].prio = p; - bubbleDown(idx); - } - - /// \brief Increase the priority of an item to the given value. - /// - /// This function increases the priority of an item to the given value. - /// \param i The item. - /// \param p The priority. - /// \pre \e i must be stored in the heap with priority at most \e p. - void increase(const Item &i, const Prio &p) { - int idx = _iim[i]; - _data[idx].prio = p; - bubbleUp(idx); - } - - /// \brief Return the state of an item. - /// - /// This method returns \c PRE_HEAP if the given item has never - /// been in the heap, \c IN_HEAP if it is in the heap at the moment, - /// and \c POST_HEAP otherwise. - /// In the latter case it is possible that the item will get back - /// to the heap again. - /// \param i The item. - State state(const Item &i) const { - int 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; - } - } - - }; // class RadixHeap - -} // namespace lemon - -#endif // LEMON_RADIX_HEAP_H Index: lemon/smart_graph.h =================================================================== --- lemon/smart_graph.h (revision 736) +++ lemon/smart_graph.h (revision 617) @@ -33,5 +33,8 @@ class SmartDigraph; - + ///Base of SmartDigraph + + ///Base of SmartDigraph + /// class SmartDigraphBase { protected: @@ -185,24 +188,26 @@ ///\brief A smart directed graph class. /// - ///\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). + ///This is a simple and fast digraph implementation. + ///It is also quite memory efficient, but at the price + ///that it does support only limited (only stack-like) + ///node and arc deletions. + ///It fully conforms to the \ref concepts::Digraph "Digraph concept". /// - ///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 + ///\sa concepts::Digraph. class SmartDigraph : public ExtendedSmartDigraphBase { typedef ExtendedSmartDigraphBase Parent; private: - /// Digraphs are \e not copy constructible. Use DigraphCopy instead. + + ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. + + ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. + /// SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {}; - /// \brief Assignment of a digraph to another one is \e not allowed. - /// Use DigraphCopy instead. + ///\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. void operator=(const SmartDigraph &) {} @@ -217,47 +222,77 @@ ///Add a new node to the digraph. - ///This function adds a new node to the digraph. - ///\return The new node. + /// Add a new node to the digraph. + /// \return The new node. Node addNode() { return Parent::addNode(); } ///Add a new arc to the digraph. - ///This function adds a new arc to the digraph with source node \c s + ///Add a new arc to the digraph with source node \c s ///and target node \c t. ///\return The new arc. - Arc addArc(Node s, Node t) { + Arc addArc(const Node& s, const 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 \c true if the given node is valid, - /// i.e. it is a real node of the digraph. + /// This function gives back true if the given node is valid, + /// ie. it is a real node of the graph. /// /// \warning A removed node (using Snapshot) could become valid again - /// if new nodes are added to the digraph. + /// when new nodes are added to the graph. bool valid(Node n) const { return Parent::valid(n); } /// \brief Arc validity check /// - /// This function gives back \c true if the given arc is valid, - /// i.e. it is a real arc of the digraph. + /// This function gives back true if the given arc is valid, + /// ie. it is a real arc of the graph. /// /// \warning A removed arc (using Snapshot) could become valid again - /// if new arcs are added to the graph. + /// when 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 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. + ///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. ///\return The newly created node. /// - ///\note All iterators remain valid. - /// + ///\note The Arcs + ///referencing a moved arc remain + ///valid. However InArc's and OutArc's + ///may be invalidated. ///\warning This functionality cannot be used together with the Snapshot ///feature. @@ -274,32 +309,4 @@ } - ///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: @@ -326,21 +333,18 @@ public: - ///Class to make a snapshot of the digraph and to restore 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 restrore to it later. /// ///The newly added nodes and arcs can be removed using the - ///restore() function. This is the only way for deleting nodes and/or - ///arcs from a SmartDigraph structure. - /// - ///\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. + ///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. + /// + ///\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. class Snapshot { @@ -354,11 +358,12 @@ ///Default constructor. - ///You have to call save() to actually make a snapshot. + ///To actually make a snapshot you must call save(). + /// Snapshot() : _graph(0) {} ///Constructor that immediately makes a snapshot - ///This constructor immediately makes a snapshot of the given digraph. - /// - Snapshot(SmartDigraph &gr) : _graph(&gr) { + ///This constructor immediately makes a snapshot of the digraph. + ///\param graph The digraph we make a snapshot of. + Snapshot(SmartDigraph &graph) : _graph(&graph) { node_num=_graph->nodes.size(); arc_num=_graph->arcs.size(); @@ -367,9 +372,12 @@ ///Make a snapshot. - ///This function makes a snapshot of the given digraph. - ///It can be called more than once. In case of a repeated + ///Make a snapshot of the digraph. + /// + ///This function can be called more than once. In case of a repeated ///call, the previous snapshot gets lost. - void save(SmartDigraph &gr) { - _graph=&gr; + ///\param graph The digraph we make the snapshot of. + void save(SmartDigraph &graph) + { + _graph=&graph; node_num=_graph->nodes.size(); arc_num=_graph->arcs.size(); @@ -378,6 +386,9 @@ ///Undo the changes until a snapshot. - ///This function undos the changes until the last snapshot - ///created by save() or Snapshot(SmartDigraph&). + ///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(). void restore() { @@ -611,24 +622,27 @@ /// \brief A smart undirected graph class. /// - /// \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). + /// This is a simple and fast graph implementation. + /// It is also quite memory efficient, but at the price + /// that it does support only limited (only stack-like) + /// node and arc deletions. + /// It fully conforms to the \ref concepts::Graph "Graph concept". /// - /// 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 + /// \sa concepts::Graph. class SmartGraph : public ExtendedSmartGraphBase { typedef ExtendedSmartGraphBase Parent; private: - /// Graphs are \e not copy constructible. Use GraphCopy instead. + + ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. + + ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. + /// SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {}; - /// \brief Assignment of a graph to another one is \e not allowed. - /// Use GraphCopy instead. + + ///\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. void operator=(const SmartGraph &) {} @@ -641,74 +655,53 @@ SmartGraph() {} - /// \brief Add a new node to the graph. - /// - /// This function adds a new node to the graph. + ///Add a new node to the graph. + + /// Add a new node to the graph. /// \return The new node. Node addNode() { return Parent::addNode(); } - /// \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); + ///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 Node validity check /// - /// This function gives back \c true if the given node is valid, - /// i.e. it is a real node of the graph. + /// This function gives back true if the given node is valid, + /// ie. it is a real node of the graph. /// /// \warning A removed node (using Snapshot) could become valid again - /// if new nodes are added to the graph. + /// when new nodes are added to the graph. 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. + /// + /// \warning A removed arc (using Snapshot) could become valid again + /// when new edges are added to the graph. + bool valid(Arc a) const { return Parent::valid(a); } + /// \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. + /// 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 - /// if new edges are added to the graph. + /// when new edges are added to the graph. bool valid(Edge e) const { return Parent::valid(e); } - /// \brief Arc validity check - /// - /// 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 - /// if new edges are added to the graph. - bool valid(Arc a) const { return Parent::valid(a); } - ///Clear the graph. - ///This function erases all nodes and arcs from the graph. + ///Erase all the nodes and edges 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: @@ -750,20 +743,19 @@ public: - ///Class to make a snapshot of the graph and to restore it later. - - ///Class to make a snapshot of the graph and to restore it later. - /// - ///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 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 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 to make a snapshot of the digraph and to restrore to it later. + + ///Class to make a snapshot of the digraph and to restrore to 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. + /// + ///\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. class Snapshot { @@ -777,28 +769,34 @@ ///Default constructor. - ///You have to call save() to actually make a snapshot. + ///To actually make a snapshot you must call save(). + /// Snapshot() : _graph(0) {} ///Constructor that immediately makes a snapshot - /// This constructor immediately makes a snapshot of the given graph. + ///This constructor immediately makes a snapshot of the digraph. + ///\param graph The digraph we make a snapshot of. + Snapshot(SmartGraph &graph) { + graph.saveSnapshot(*this); + } + + ///Make a snapshot. + + ///Make a snapshot of the graph. /// - Snapshot(SmartGraph &gr) { - gr.saveSnapshot(*this); - } - - ///Make a snapshot. - - ///This function makes a snapshot of the given graph. - ///It can be called more than once. In case of a repeated + ///This function can be called more than once. In case of a repeated ///call, the previous snapshot gets lost. - void save(SmartGraph &gr) + ///\param graph The digraph we make the snapshot of. + void save(SmartGraph &graph) { - gr.saveSnapshot(*this); - } - - ///Undo the changes until the last snapshot. - - ///This function undos the changes until the last snapshot - ///created by save() or Snapshot(SmartGraph&). + graph.saveSnapshot(*this); + } + + ///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(). void restore() { Index: lemon/soplex.cc =================================================================== --- lemon/soplex.cc (revision 746) +++ lemon/soplex.cc (revision 576) @@ -92,17 +92,4 @@ } - 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) { Index: lemon/soplex.h =================================================================== --- lemon/soplex.h (revision 746) +++ lemon/soplex.h (revision 576) @@ -85,5 +85,4 @@ virtual int _addCol(); virtual int _addRow(); - virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); virtual void _eraseCol(int i); Index: ripts/bib2dox.py =================================================================== --- scripts/bib2dox.py (revision 745) +++ (revision ) @@ -1,806 +1,0 @@ -#!/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 - LAST_NAME, FIRST_NAME - 3. Does not handle "crossref" fields other than to print - ... - 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('({\w*})') - -# 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'\1', 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 @{, - 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 @{, - 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'] = '' + entrycont['title'] + '' - if not entrycont.has_key('author'): - entrycont['author'] = entrycont['editor'] - entrycont['author']['text'] += ', editors' - elif entrytype == 'article': - entrycont['journal'] = '' + entrycont['journal'] + '' - elif entrytype in ('inproceedings', 'incollection', 'conference'): - entrycont['booktitle'] = '' + entrycont['booktitle'] + '' - 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'] + '.') - - # 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 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('
') - for line in entry[3:]: - file.append(line) - file.append('
') - 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 Index: ripts/bootstrap.sh =================================================================== --- scripts/bootstrap.sh (revision 747) +++ (revision ) @@ -1,134 +1,0 @@ -#!/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 <>~/.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 \ -$* Index: scripts/chg-len.py =================================================================== --- scripts/chg-len.py (revision 733) +++ scripts/chg-len.py (revision 422) @@ -1,17 +1,3 @@ #! /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 Index: scripts/mk-release.sh =================================================================== --- scripts/mk-release.sh (revision 733) +++ scripts/mk-release.sh (revision 564) @@ -1,17 +1,3 @@ #!/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 Index: scripts/unify-sources.sh =================================================================== --- scripts/unify-sources.sh (revision 733) +++ scripts/unify-sources.sh (revision 655) @@ -1,17 +1,3 @@ #!/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` Index: test/CMakeLists.txt =================================================================== --- test/CMakeLists.txt (revision 698) +++ test/CMakeLists.txt (revision 679) @@ -10,5 +10,4 @@ SET(TESTS adaptors_test - bellman_ford_test bfs_test circulation_test Index: test/Makefile.am =================================================================== --- test/Makefile.am (revision 698) +++ test/Makefile.am (revision 649) @@ -8,5 +8,4 @@ check_PROGRAMS += \ test/adaptors_test \ - test/bellman_ford_test \ test/bfs_test \ test/circulation_test \ @@ -54,5 +53,4 @@ 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 Index: st/bellman_ford_test.cc =================================================================== --- test/bellman_ford_test.cc (revision 699) +++ (revision ) @@ -1,283 +1,0 @@ -/* -*- mode: C++; indent-tabs-mode: nil; -*- - * - * This file is a part of LEMON, a generic C++ optimization library. - * - * Copyright (C) 2003-2009 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport - * (Egervary Research Group on Combinatorial Optimization, EGRES). - * - * Permission to use, modify and distribute this software is granted - * provided that this copyright notice appears in all copies. For - * precise terms see the accompanying LICENSE file. - * - * This software is provided "AS IS" with no warranty of any kind, - * express or implied, and with no claim as to its suitability for any - * purpose. - * - */ - -#include -#include -#include -#include -#include -#include - -#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 LengthMap; - typedef BellmanFord 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 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 > - ::SetDistMap > - ::SetOperationTraits > - ::Create bf_test(gr,length); - - LengthMap length_map; - concepts::ReadWriteMap pred_map; - concepts::ReadWriteMap 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 LengthMap; - - Digraph g; - bool b; - bellmanFord(g,LengthMap()).run(Node()); - b = bellmanFord(g,LengthMap()).run(Node(),Node()); - bellmanFord(g,LengthMap()) - .predMap(concepts::ReadWriteMap()) - .distMap(concepts::ReadWriteMap()) - .run(Node()); - b=bellmanFord(g,LengthMap()) - .predMap(concepts::ReadWriteMap()) - .distMap(concepts::ReadWriteMap()) - .path(concepts::Path()) - .dist(Value()) - .run(Node(),Node()); -} - - -template -void checkBellmanFord() { - TEMPLATE_DIGRAPH_TYPEDEFS(Digraph); - typedef typename Digraph::template ArcMap 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 - bf(gr, length); - bf.run(s); - Path 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 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 bf(gr, length); - bf.run(n1); - StaticPath p = bf.negativeCycle(); - check(p.length() == 1 && p.front() == p.back() && p.front() == a2, - "Wrong negative cycle."); - } - - length[a2] = 0; - - { - BellmanFord 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 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 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(); - checkBellmanFord(); - checkBellmanFordNegativeCycle(); - return 0; -} Index: test/circulation_test.cc =================================================================== --- test/circulation_test.cc (revision 689) +++ test/circulation_test.cc (revision 611) @@ -88,9 +88,4 @@ .supplyMap(supply) .flowMap(flow); - - const CirculationType::Elevator& elev = const_circ_test.elevator(); - circ_test.elevator(const_cast(elev)); - CirculationType::Tolerance tol = const_circ_test.tolerance(); - circ_test.tolerance(tol); circ_test.init(); Index: test/digraph_test.cc =================================================================== --- test/digraph_test.cc (revision 740) +++ test/digraph_test.cc (revision 440) @@ -36,7 +36,4 @@ checkGraphArcList(G, 0); - G.reserveNode(3); - G.reserveArc(4); - Node n1 = G.addNode(), @@ -287,12 +284,4 @@ snapshot.restore(); - snapshot.save(G); - - checkGraphNodeList(G, 4); - checkGraphArcList(G, 4); - - G.addArc(G.addNode(), G.addNode()); - - snapshot.restore(); checkGraphNodeList(G, 4); @@ -387,10 +376,5 @@ 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); Index: test/graph_test.cc =================================================================== --- test/graph_test.cc (revision 740) +++ test/graph_test.cc (revision 440) @@ -39,7 +39,4 @@ checkGraphArcList(G, 0); - G.reserveNode(3); - G.reserveEdge(3); - Node n1 = G.addNode(), @@ -260,17 +257,8 @@ 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); - checkGraphArcList(G, 6); } @@ -280,11 +268,4 @@ 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); @@ -431,8 +412,4 @@ 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) { @@ -510,9 +487,4 @@ 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))); Index: test/heap_test.cc =================================================================== --- test/heap_test.cc (revision 702) +++ test/heap_test.cc (revision 440) @@ -26,4 +26,5 @@ #include + #include #include @@ -31,11 +32,4 @@ #include -#include -#include -#include -#include -#include -#include -#include #include "test_tools.h" @@ -93,7 +87,9 @@ void heapSortTest() { RangeMap map(test_len, -1); + Heap heap(map); std::vector v(test_len); + for (int i = 0; i < test_len; ++i) { v[i] = test_seq[i]; @@ -102,5 +98,5 @@ 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(); } @@ -114,4 +110,5 @@ std::vector v(test_len); + for (int i = 0; i < test_len; ++i) { v[i] = test_seq[i]; @@ -124,8 +121,10 @@ 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 @@ -143,5 +142,5 @@ if (dijkstra.reached(s)) { check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a], - "Error in shortest path tree."); + "Error in a shortest path tree!"); } } @@ -152,5 +151,5 @@ Node s = digraph.source(a); check( dijkstra.dist(n) - dijkstra.dist(s) == length[a], - "Error in shortest path tree."); + "Error in a shortest path tree!"); } } @@ -174,5 +173,4 @@ run(); - // BinHeap { typedef BinHeap IntHeap; @@ -186,91 +184,4 @@ } - // FouraryHeap - { - typedef FouraryHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef FouraryHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // KaryHeap - { - typedef KaryHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef KaryHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // FibHeap - { - typedef FibHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef FibHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // PairingHeap - { - typedef PairingHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef PairingHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // RadixHeap - { - typedef RadixHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef RadixHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // BinomHeap - { - typedef BinomHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef BinomHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - } - - // BucketHeap, SimpleBucketHeap - { - typedef BucketHeap IntHeap; - checkConcept, IntHeap>(); - heapSortTest(); - heapIncreaseTest(); - - typedef BucketHeap NodeHeap; - checkConcept, NodeHeap>(); - dijkstraHeapTest(digraph, length, source); - - typedef SimpleBucketHeap SimpleIntHeap; - heapSortTest(); - } - return 0; } Index: test/maps_test.cc =================================================================== --- test/maps_test.cc (revision 726) +++ test/maps_test.cc (revision 477) @@ -23,8 +23,4 @@ #include #include -#include -#include -#include -#include #include "test_tools.h" @@ -64,10 +60,4 @@ typedef ReadWriteMap BoolWriteMap; typedef ReferenceMap BoolRefMap; - -template -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() @@ -339,8 +329,4 @@ { typedef std::vector vec; - checkConcept, LoggerBoolMap >(); - checkConcept, - LoggerBoolMap > >(); - vec v1; vec v2(10); @@ -362,443 +348,6 @@ 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 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 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, IdMap >(); - checkConcept, IdMap >(); - checkConcept, RangeIdMap >(); - checkConcept, RangeIdMap >(); - - Graph gr; - IdMap nmap(gr); - IdMap amap(gr); - RangeIdMap nrmap(gr); - RangeIdMap 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, SourceMap >(); - checkConcept, TargetMap >(); - checkConcept, ForwardMap >(); - checkConcept, BackwardMap >(); - checkConcept, InDegMap >(); - checkConcept, OutDegMap >(); - - 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(true))), - targetMap(orienter(gr, constMap(false))), - EdgeIt(gr)); - - typedef Orienter > Digraph; - Digraph dgr(gr, constMap(true)); - OutDegMap odm(dgr); - InDegMap 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, - CrossRefMap >(); - checkConcept, - CrossRefMap >(); - checkConcept, - CrossRefMap >(); - - Graph gr; - typedef CrossRefMap 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, - CrossRefMap >(); - - Graph gr; - typedef CrossRefMap 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 Ibm; - checkConcept, Ibm>(); - - const int num = 10; - Graph g; - std::vector 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(it)], "Wrong TrueIt"); - ++n; - } - check(n == num, "Wrong number"); - - n = 0; - for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { - check(map1[static_cast(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(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(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(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(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(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 Iim; - - checkConcept, Iim>(); - - const int num = 10; - Graph g; - std::vector 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(it) == items[i], "Wrong value"); - ++it; - check(static_cast(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(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(it)] == 1, "Wrong value"); - ++n; - } - check(n == num, "Wrong number"); - - } - - // Iterable value map - { - typedef SmartGraph Graph; - typedef SmartGraph::Node Item; - typedef IterableValueMap Ivm; - - checkConcept, Ivm>(); - - const int num = 10; - Graph g; - std::vector 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(i)); - } - check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size"); - - for (int i = 0; i < num; ++i) { - Ivm::ItemIt it(map1, static_cast(i)); - check(static_cast(it) == items[i], "Wrong value"); - ++it; - check(static_cast(it) == INVALID, "Wrong value"); - } - - for (Ivm::ValueIt vit = map1.beginValue(); - vit != map1.endValue(); ++vit) { - check(map1[static_cast(Ivm::ItemIt(map1, *vit))] == *vit, - "Wrong ValueIt"); - } - - for (int i = 0; i < num; ++i) { - map1.set(items[i], static_cast(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(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(it)] == 1.0, "Wrong value"); - ++n; - } - check(n == num, "Wrong number"); - - } + } + return 0; } Index: test/preflow_test.cc =================================================================== --- test/preflow_test.cc (revision 689) +++ test/preflow_test.cc (revision 585) @@ -95,9 +95,4 @@ 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(elev)); - PreflowType::Tolerance tol = const_preflow_test.tolerance(); - preflow_test.tolerance(tol); preflow_test Index: tools/lemon-0.x-to-1.x.sh =================================================================== --- tools/lemon-0.x-to-1.x.sh (revision 691) +++ tools/lemon-0.x-to-1.x.sh (revision 574) @@ -36,8 +36,8 @@ -e "s/Edge\>/_Ar_c_label_/g"\ -e "s/\/_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/\/_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"\ @@ -69,9 +69,4 @@ -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\ -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\ - -e "s/\/adaptors.h/g"\ - -e "s/\/core.h/g"\ - -e "s/\/lgf_reader.h/g"\ - -e "s/\/lgf_writer.h/g"\ - -e "s/\/connectivity.h/g"\ -e "s/DigraphToEps/GraphToEps/g"\ -e "s/digraphToEps/graphToEps/g"\