Changes in / [827:580af8cf2f6a:826:c160bf9f18ef] in lemon
- Files:
-
- 13 deleted
- 64 edited
Legend:
- Unmodified
- Added
- Removed
-
CMakeLists.txt
r791 r727 35 35 CHECK_TYPE_SIZE("long long" LONG_LONG) 36 36 SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) 37 38 INCLUDE(FindPythonInterp)39 37 40 38 ENABLE_TESTING() -
Makefile.am
r799 r676 18 18 cmake/FindGLPK.cmake \ 19 19 cmake/FindCOIN.cmake \ 20 cmake/LEMONConfig.cmake.in \21 20 cmake/version.cmake.in \ 22 21 cmake/version.cmake \ -
configure.ac
r791 r727 42 42 43 43 AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) 44 AC_CHECK_PROG([python_found],[python],[yes],[no])45 44 AC_CHECK_PROG([gs_found],[gs],[yes],[no]) 46 45 -
doc/CMakeLists.txt
r791 r726 10 10 ) 11 11 12 IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND ANDGHOSTSCRIPT_EXECUTABLE)12 IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE) 13 13 FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/) 14 14 SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha) … … 29 29 COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps 30 30 COMMAND ${CMAKE_COMMAND} -E remove_directory html 31 COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox32 31 COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile 33 32 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} -
doc/Doxyfile.in
r803 r379 1 # Doxyfile 1.5. 91 # Doxyfile 1.5.7.1 2 2 3 3 #--------------------------------------------------------------------------- … … 22 22 QT_AUTOBRIEF = NO 23 23 MULTILINE_CPP_IS_BRIEF = NO 24 DETAILS_AT_TOP = YES 24 25 INHERIT_DOCS = NO 25 26 SEPARATE_MEMBER_PAGES = NO … … 91 92 "@abs_top_srcdir@/demo" \ 92 93 "@abs_top_srcdir@/tools" \ 93 "@abs_top_srcdir@/test/test_tools.h" \ 94 "@abs_top_builddir@/doc/references.dox" 94 "@abs_top_srcdir@/test/test_tools.h" 95 95 INPUT_ENCODING = UTF-8 96 96 FILE_PATTERNS = *.h \ … … 224 224 SKIP_FUNCTION_MACROS = YES 225 225 #--------------------------------------------------------------------------- 226 # Options related to the search engine226 # Configuration::additions related to external references 227 227 #--------------------------------------------------------------------------- 228 228 TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ " -
doc/Makefile.am
r791 r720 67 67 fi 68 68 69 references.dox: doc/references.bib 70 if test ${python_found} = yes; then \ 71 cd doc; \ 72 python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \ 73 cd ..; \ 74 else \ 75 echo; \ 76 echo "Python not found."; \ 77 echo; \ 78 exit 1; \ 79 fi 80 81 html-local: $(DOC_PNG_IMAGES) references.dox 69 html-local: $(DOC_PNG_IMAGES) 82 70 if test ${doxygen_found} = yes; then \ 83 71 cd doc; \ -
doc/groups.dox
r818 r710 227 227 228 228 /** 229 @defgroup matrices Matrices 230 @ingroup datas 231 \brief Two dimensional data storages implemented in LEMON. 232 233 This group contains two dimensional data storages implemented in LEMON. 234 */ 235 236 /** 229 237 @defgroup paths Path Structures 230 238 @ingroup datas … … 239 247 any kind of path structure. 240 248 241 \sa \ref concepts::Path "Path concept" 242 */ 243 244 /** 245 @defgroup heaps Heap Structures 246 @ingroup datas 247 \brief %Heap structures implemented in LEMON. 248 249 This group contains the heap structures implemented in LEMON. 250 251 LEMON provides several heap classes. They are efficient implementations 252 of the abstract data type \e priority \e queue. They store items with 253 specified values called \e priorities in such a way that finding and 254 removing the item with minimum priority are efficient. 255 The basic operations are adding and erasing items, changing the priority 256 of an item, etc. 257 258 Heaps are crucial in several algorithms, such as Dijkstra and Prim. 259 The heap implementations have the same interface, thus any of them can be 260 used easily in such algorithms. 261 262 \sa \ref concepts::Heap "Heap concept" 263 */ 264 265 /** 266 @defgroup matrices Matrices 267 @ingroup datas 268 \brief Two dimensional data storages implemented in LEMON. 269 270 This group contains two dimensional data storages implemented in LEMON. 249 \sa lemon::concepts::Path 271 250 */ 272 251 … … 281 260 282 261 /** 283 @defgroup geomdat Geometric Data Structures284 @ingroup auxdat285 \brief Geometric data structures implemented in LEMON.286 287 This group contains geometric data structures implemented in LEMON.288 289 - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional290 vector with the usual operations.291 - \ref lemon::dim2::Box "dim2::Box" can be used to determine the292 rectangular bounding box of a set of \ref lemon::dim2::Point293 "dim2::Point"'s.294 */295 296 /**297 @defgroup matrices Matrices298 @ingroup auxdat299 \brief Two dimensional data storages implemented in LEMON.300 301 This group contains two dimensional data storages implemented in LEMON.302 */303 304 /**305 262 @defgroup algs Algorithms 306 263 \brief This group contains the several algorithms … … 317 274 318 275 This group contains the common graph search algorithms, namely 319 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS) 320 \ref clrs01algorithms. 276 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS). 321 277 */ 322 278 … … 326 282 \brief Algorithms for finding shortest paths. 327 283 328 This group contains the algorithms for finding shortest paths in digraphs 329 \ref clrs01algorithms. 284 This group contains the algorithms for finding shortest paths in digraphs. 330 285 331 286 - \ref Dijkstra algorithm for finding shortest paths from a source node … … 344 299 345 300 /** 346 @defgroup spantree Minimum Spanning Tree Algorithms347 @ingroup algs348 \brief Algorithms for finding minimum cost spanning trees and arborescences.349 350 This group contains the algorithms for finding minimum cost spanning351 trees and arborescences \ref clrs01algorithms.352 */353 354 /**355 301 @defgroup max_flow Maximum Flow Algorithms 356 302 @ingroup algs … … 358 304 359 305 This group contains the algorithms for finding maximum flows and 360 feasible circulations \ref clrs01algorithms, \ref amo93networkflows.306 feasible circulations. 361 307 362 308 The \e maximum \e flow \e problem is to find a flow of maximum value between … … 373 319 374 320 LEMON contains several algorithms for solving maximum flow problems: 375 - \ref EdmondsKarp Edmonds-Karp algorithm 376 \ref edmondskarp72theoretical. 377 - \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm 378 \ref goldberg88newapproach. 379 - \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees 380 \ref dinic70algorithm, \ref sleator83dynamic. 381 - \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees 382 \ref goldberg88newapproach, \ref sleator83dynamic. 383 384 In most cases the \ref Preflow algorithm provides the 321 - \ref EdmondsKarp Edmonds-Karp algorithm. 322 - \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm. 323 - \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees. 324 - \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees. 325 326 In most cases the \ref Preflow "Preflow" algorithm provides the 385 327 fastest method for computing a maximum flow. All implementations 386 328 also provide functions to query the minimum cut, which is the dual … … 400 342 401 343 This group contains the algorithms for finding minimum cost flows and 402 circulations \ref amo93networkflows. For more information about this 403 problem and its dual solution, see \ref min_cost_flow 404 "Minimum Cost Flow Problem". 344 circulations. For more information about this problem and its dual 345 solution see \ref min_cost_flow "Minimum Cost Flow Problem". 405 346 406 347 LEMON contains several algorithms for this problem. 407 348 - \ref NetworkSimplex Primal Network Simplex algorithm with various 408 pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.349 pivot strategies. 409 350 - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on 410 cost scaling \ref goldberg90approximation, \ref goldberg97efficient, 411 \ref bunnagel98efficient. 351 cost scaling. 412 352 - \ref CapacityScaling Successive Shortest %Path algorithm with optional 413 capacity scaling \ref edmondskarp72theoretical. 414 - \ref CancelAndTighten The Cancel and Tighten algorithm 415 \ref goldberg89cyclecanceling. 416 - \ref CycleCanceling Cycle-Canceling algorithms 417 \ref klein67primal, \ref goldberg89cyclecanceling. 353 capacity scaling. 354 - \ref CancelAndTighten The Cancel and Tighten algorithm. 355 - \ref CycleCanceling Cycle-Canceling algorithms. 418 356 419 357 In general NetworkSimplex is the most efficient implementation, … … 438 376 439 377 \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} 440 \sum_{uv\in A :u\in X, v\not\in X}cap(uv) \f]378 \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f] 441 379 442 380 LEMON contains several algorithms related to minimum cut problems: … … 454 392 455 393 /** 456 @defgroup min_mean_cycle Minimum Mean Cycle Algorithms 457 @ingroup algs 458 \brief Algorithms for finding minimum mean cycles. 459 460 This group contains the algorithms for finding minimum mean cycles 461 \ref clrs01algorithms, \ref amo93networkflows. 462 463 The \e minimum \e mean \e cycle \e problem is to find a directed cycle 464 of minimum mean length (cost) in a digraph. 465 The mean length of a cycle is the average length of its arcs, i.e. the 466 ratio between the total length of the cycle and the number of arcs on it. 467 468 This problem has an important connection to \e conservative \e length 469 \e functions, too. A length function on the arcs of a digraph is called 470 conservative if and only if there is no directed cycle of negative total 471 length. For an arbitrary length function, the negative of the minimum 472 cycle mean is the smallest \f$\epsilon\f$ value so that increasing the 473 arc lengths uniformly by \f$\epsilon\f$ results in a conservative length 474 function. 475 476 LEMON contains three algorithms for solving the minimum mean cycle problem: 477 - \ref Karp "Karp"'s original algorithm \ref amo93networkflows, 478 \ref dasdan98minmeancycle. 479 - \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved 480 version of Karp's algorithm \ref dasdan98minmeancycle. 481 - \ref Howard "Howard"'s policy iteration algorithm 482 \ref dasdan98minmeancycle. 483 484 In practice, the Howard algorithm proved to be by far the most efficient 485 one, though the best known theoretical bound on its running time is 486 exponential. 487 Both Karp and HartmannOrlin algorithms run in time O(ne) and use space 488 O(n<sup>2</sup>+e), but the latter one is typically faster due to the 489 applied early termination scheme. 394 @defgroup graph_properties Connectivity and Other Graph Properties 395 @ingroup algs 396 \brief Algorithms for discovering the graph properties 397 398 This group contains the algorithms for discovering the graph properties 399 like connectivity, bipartiteness, euler property, simplicity etc. 400 401 \image html edge_biconnected_components.png 402 \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth 403 */ 404 405 /** 406 @defgroup planar Planarity Embedding and Drawing 407 @ingroup algs 408 \brief Algorithms for planarity checking, embedding and drawing 409 410 This group contains the algorithms for planarity checking, 411 embedding and drawing. 412 413 \image html planar.png 414 \image latex planar.eps "Plane graph" width=\textwidth 490 415 */ 491 416 … … 531 456 532 457 /** 533 @defgroup graph_properties Connectivity and Other Graph Properties 534 @ingroup algs 535 \brief Algorithms for discovering the graph properties 536 537 This group contains the algorithms for discovering the graph properties 538 like connectivity, bipartiteness, euler property, simplicity etc. 539 540 \image html connected_components.png 541 \image latex connected_components.eps "Connected components" width=\textwidth 542 */ 543 544 /** 545 @defgroup planar Planarity Embedding and Drawing 546 @ingroup algs 547 \brief Algorithms for planarity checking, embedding and drawing 548 549 This group contains the algorithms for planarity checking, 550 embedding and drawing. 551 552 \image html planar.png 553 \image latex planar.eps "Plane graph" width=\textwidth 458 @defgroup spantree Minimum Spanning Tree Algorithms 459 @ingroup algs 460 \brief Algorithms for finding minimum cost spanning trees and arborescences. 461 462 This group contains the algorithms for finding minimum cost spanning 463 trees and arborescences. 464 */ 465 466 /** 467 @defgroup auxalg Auxiliary Algorithms 468 @ingroup algs 469 \brief Auxiliary algorithms implemented in LEMON. 470 471 This group contains some algorithms implemented in LEMON 472 in order to make it easier to implement complex algorithms. 554 473 */ 555 474 … … 561 480 This group contains the approximation and heuristic algorithms 562 481 implemented in LEMON. 563 */564 565 /**566 @defgroup auxalg Auxiliary Algorithms567 @ingroup algs568 \brief Auxiliary algorithms implemented in LEMON.569 570 This group contains some algorithms implemented in LEMON571 in order to make it easier to implement complex algorithms.572 482 */ 573 483 … … 582 492 583 493 /** 584 @defgroup lp_group L P and MIPSolvers494 @defgroup lp_group Lp and Mip Solvers 585 495 @ingroup gen_opt_group 586 \brief LP and MIP solver interfaces for LEMON. 587 588 This group contains LP and MIP solver interfaces for LEMON. 589 Various LP solvers could be used in the same manner with this 590 high-level interface. 591 592 The currently supported solvers are \ref glpk, \ref clp, \ref cbc, 593 \ref cplex, \ref soplex. 496 \brief Lp and Mip solver interfaces for LEMON. 497 498 This group contains Lp and Mip solver interfaces for LEMON. The 499 various LP solvers could be used in the same manner with this 500 interface. 594 501 */ 595 502 … … 681 588 682 589 /** 683 @defgroup dimacs_group DIMACS Format590 @defgroup dimacs_group DIMACS format 684 591 @ingroup io_group 685 592 \brief Read and write files in DIMACS format … … 730 637 \brief Skeleton and concept checking classes for graph structures 731 638 732 This group contains the skeletons and concept checking classes of 733 graph structures .639 This group contains the skeletons and concept checking classes of LEMON's 640 graph structures and helper classes used to implement these. 734 641 */ 735 642 … … 743 650 744 651 /** 652 \anchor demoprograms 653 654 @defgroup demos Demo Programs 655 656 Some demo programs are listed here. Their full source codes can be found in 657 the \c demo subdirectory of the source tree. 658 659 In order to compile them, use the <tt>make demo</tt> or the 660 <tt>make check</tt> commands. 661 */ 662 663 /** 745 664 @defgroup tools Standalone Utility Applications 746 665 … … 751 670 */ 752 671 753 /**754 \anchor demoprograms755 756 @defgroup demos Demo Programs757 758 Some demo programs are listed here. Their full source codes can be found in759 the \c demo subdirectory of the source tree.760 761 In order to compile them, use the <tt>make demo</tt> or the762 <tt>make check</tt> commands.763 */764 765 672 } -
doc/mainpage.dox
r802 r705 22 22 \section intro Introduction 23 23 24 <b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling 25 and <b>O</b>ptimization in <b>N</b>etworks</i>. 26 It is a C++ template library providing efficient implementation of common 27 data structures and algorithms with focus on combinatorial optimization 28 problems in graphs and networks. 24 \subsection whatis What is LEMON 25 26 LEMON stands for <b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling 27 and <b>O</b>ptimization in <b>N</b>etworks. 28 It is a C++ template 29 library aimed at combinatorial optimization tasks which 30 often involve in working 31 with graphs. 29 32 30 33 <b> … … 36 39 </b> 37 40 38 The project is maintained by the 39 <a href="http://www.cs.elte.hu/egres/">Egerváry Research Group on 40 Combinatorial Optimization</a> \ref egres 41 at the Operations Research Department of the 42 <a href="http://www.elte.hu/">Eötvös Loránd University, 43 Budapest</a>, Hungary. 44 LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a> 45 initiative \ref coinor. 46 47 \section howtoread How to Read the Documentation 41 \subsection howtoread How to read the documentation 48 42 49 43 If you would like to get to know the library, see -
doc/min_cost_flow.dox
r802 r710 27 27 minimum total cost from a set of supply nodes to a set of demand nodes 28 28 in a network with capacity constraints (lower and upper bounds) 29 and arc costs \ref amo93networkflows.29 and arc costs. 30 30 31 31 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$, -
lemon/Makefile.am
r827 r820 58 58 lemon/arg_parser.h \ 59 59 lemon/assert.h \ 60 lemon/bellman_ford.h \61 60 lemon/bfs.h \ 62 61 lemon/bin_heap.h \ 63 lemon/binom_heap.h \64 62 lemon/bucket_heap.h \ 65 63 lemon/cbc.h \ … … 81 79 lemon/euler.h \ 82 80 lemon/fib_heap.h \ 83 lemon/fourary_heap.h \84 81 lemon/full_graph.h \ 85 82 lemon/glpk.h \ … … 87 84 lemon/graph_to_eps.h \ 88 85 lemon/grid_graph.h \ 89 lemon/hartmann_orlin.h \90 lemon/howard.h \91 86 lemon/hypercube_graph.h \ 92 lemon/karp.h \93 lemon/kary_heap.h \94 87 lemon/kruskal.h \ 95 88 lemon/hao_orlin.h \ … … 106 99 lemon/nauty_reader.h \ 107 100 lemon/network_simplex.h \ 108 lemon/pairing_heap.h \109 101 lemon/path.h \ 110 102 lemon/preflow.h \ -
lemon/bfs.h
r764 r525 48 48 ///The type of the map that stores the predecessor 49 49 ///arcs of the shortest paths. 50 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.50 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 51 51 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 52 52 ///Instantiates a \c PredMap. … … 63 63 64 64 ///The type of the map that indicates which nodes are processed. 65 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 66 ///By default it is a NullMap. 65 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 67 66 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; 68 67 ///Instantiates a \c ProcessedMap. … … 83 82 84 83 ///The type of the map that indicates which nodes are reached. 85 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.84 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 86 85 typedef typename Digraph::template NodeMap<bool> ReachedMap; 87 86 ///Instantiates a \c ReachedMap. … … 98 97 99 98 ///The type of the map that stores the distances of the nodes. 100 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.99 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 101 100 typedef typename Digraph::template NodeMap<int> DistMap; 102 101 ///Instantiates a \c DistMap. … … 227 226 ///\ref named-templ-param "Named parameter" for setting 228 227 ///\c PredMap type. 229 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.228 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 230 229 template <class T> 231 230 struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > { … … 247 246 ///\ref named-templ-param "Named parameter" for setting 248 247 ///\c DistMap type. 249 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.248 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 250 249 template <class T> 251 250 struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > { … … 267 266 ///\ref named-templ-param "Named parameter" for setting 268 267 ///\c ReachedMap type. 269 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.268 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 270 269 template <class T> 271 270 struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > { … … 287 286 ///\ref named-templ-param "Named parameter" for setting 288 287 ///\c ProcessedMap type. 289 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.288 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 290 289 template <class T> 291 290 struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > { … … 415 414 ///The simplest way to execute the BFS algorithm is to use one of the 416 415 ///member functions called \ref run(Node) "run()".\n 417 ///If you need better control on the execution,you have to call418 ///\ref init() first, then you can add several source nodes with416 ///If you need more control on the execution, first you have to call 417 ///\ref init(), then you can add several source nodes with 419 418 ///\ref addSource(). Finally the actual path computation can be 420 419 ///performed with one of the \ref start() functions. … … 739 738 ///@{ 740 739 741 ///The shortest path to the givennode.742 743 ///Returns the shortest path to the given node from the root(s).740 ///The shortest path to a node. 741 742 ///Returns the shortest path to a node. 744 743 /// 745 744 ///\warning \c t should be reached from the root(s). … … 749 748 Path path(Node t) const { return Path(*G, *_pred, t); } 750 749 751 ///The distance of the givennode from the root(s).752 753 ///Returns the distance of the givennode from the root(s).750 ///The distance of a node from the root(s). 751 752 ///Returns the distance of a node from the root(s). 754 753 /// 755 754 ///\warning If node \c v is not reached from the root(s), then … … 760 759 int dist(Node v) const { return (*_dist)[v]; } 761 760 762 ///\brief Returns the 'previous arc' of the shortest path tree for 763 ///the given node. 764 /// 761 ///Returns the 'previous arc' of the shortest path tree for a node. 762 765 763 ///This function returns the 'previous arc' of the shortest path 766 764 ///tree for the node \c v, i.e. it returns the last arc of a … … 769 767 /// 770 768 ///The shortest path tree used here is equal to the shortest path 771 ///tree used in \ref predNode() and \ref predMap().769 ///tree used in \ref predNode(). 772 770 /// 773 771 ///\pre Either \ref run(Node) "run()" or \ref init() … … 775 773 Arc predArc(Node v) const { return (*_pred)[v];} 776 774 777 ///\brief Returns the 'previous node' of the shortest path tree for 778 ///the given node. 779 /// 775 ///Returns the 'previous node' of the shortest path tree for a node. 776 780 777 ///This function returns the 'previous node' of the shortest path 781 778 ///tree for the node \c v, i.e. it returns the last but one node 782 /// ofa shortest path from a root to \c v. It is \c INVALID779 ///from a shortest path from a root to \c v. It is \c INVALID 783 780 ///if \c v is not reached from the root(s) or if \c v is a root. 784 781 /// 785 782 ///The shortest path tree used here is equal to the shortest path 786 ///tree used in \ref predArc() and \ref predMap().783 ///tree used in \ref predArc(). 787 784 /// 788 785 ///\pre Either \ref run(Node) "run()" or \ref init() … … 805 802 /// 806 803 ///Returns a const reference to the node map that stores the predecessor 807 ///arcs, which form the shortest path tree (forest).804 ///arcs, which form the shortest path tree. 808 805 /// 809 806 ///\pre Either \ref run(Node) "run()" or \ref init() … … 811 808 const PredMap &predMap() const { return *_pred;} 812 809 813 ///Checks if the givennode is reached from the root(s).810 ///Checks if a node is reached from the root(s). 814 811 815 812 ///Returns \c true if \c v is reached from the root(s). … … 837 834 ///The type of the map that stores the predecessor 838 835 ///arcs of the shortest paths. 839 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.836 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 840 837 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 841 838 ///Instantiates a PredMap. … … 852 849 853 850 ///The type of the map that indicates which nodes are processed. 854 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.851 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 855 852 ///By default it is a NullMap. 856 853 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 872 869 873 870 ///The type of the map that indicates which nodes are reached. 874 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.871 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 875 872 typedef typename Digraph::template NodeMap<bool> ReachedMap; 876 873 ///Instantiates a ReachedMap. … … 887 884 888 885 ///The type of the map that stores the distances of the nodes. 889 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.886 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 890 887 typedef typename Digraph::template NodeMap<int> DistMap; 891 888 ///Instantiates a DistMap. … … 902 899 903 900 ///The type of the shortest paths. 904 ///It must conform tothe \ref concepts::Path "Path" concept.901 ///It must meet the \ref concepts::Path "Path" concept. 905 902 typedef lemon::Path<Digraph> Path; 906 903 }; … … 908 905 /// Default traits class used by BfsWizard 909 906 910 /// Default traits class used by BfsWizard. 911 /// \tparam GR The type of the digraph. 907 /// To make it easier to use Bfs algorithm 908 /// we have created a wizard class. 909 /// This \ref BfsWizard class needs default traits, 910 /// as well as the \ref Bfs class. 911 /// The \ref BfsWizardBase is a class to be the default traits of the 912 /// \ref BfsWizard class. 912 913 template<class GR> 913 914 class BfsWizardBase : public BfsWizardDefaultTraits<GR> … … 937 938 /// Constructor. 938 939 939 /// This constructor does not require parameters, it initiates940 /// This constructor does not require parameters, therefore it initiates 940 941 /// all of the attributes to \c 0. 941 942 BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), … … 967 968 typedef TR Base; 968 969 970 ///The type of the digraph the algorithm runs on. 969 971 typedef typename TR::Digraph Digraph; 970 972 … … 974 976 typedef typename Digraph::OutArcIt OutArcIt; 975 977 978 ///\brief The type of the map that stores the predecessor 979 ///arcs of the shortest paths. 976 980 typedef typename TR::PredMap PredMap; 981 ///\brief The type of the map that stores the distances of the nodes. 977 982 typedef typename TR::DistMap DistMap; 983 ///\brief The type of the map that indicates which nodes are reached. 978 984 typedef typename TR::ReachedMap ReachedMap; 985 ///\brief The type of the map that indicates which nodes are processed. 979 986 typedef typename TR::ProcessedMap ProcessedMap; 987 ///The type of the shortest paths 980 988 typedef typename TR::Path Path; 981 989 … … 1060 1068 SetPredMapBase(const TR &b) : TR(b) {} 1061 1069 }; 1062 1063 ///\brief \ref named-templ-param "Named parameter" for setting 1064 ///the predecessor map. 1065 /// 1066 ///\ref named-templ-param "Named parameter" function for setting 1067 ///the map that stores the predecessor arcs of the nodes. 1070 ///\brief \ref named-func-param "Named parameter" 1071 ///for setting PredMap object. 1072 /// 1073 ///\ref named-func-param "Named parameter" 1074 ///for setting PredMap object. 1068 1075 template<class T> 1069 1076 BfsWizard<SetPredMapBase<T> > predMap(const T &t) … … 1079 1086 SetReachedMapBase(const TR &b) : TR(b) {} 1080 1087 }; 1081 1082 ///\brief \ref named-templ-param "Named parameter" for setting 1083 ///the reached map. 1084 /// 1085 ///\ref named-templ-param "Named parameter" function for setting 1086 ///the map that indicates which nodes are reached. 1088 ///\brief \ref named-func-param "Named parameter" 1089 ///for setting ReachedMap object. 1090 /// 1091 /// \ref named-func-param "Named parameter" 1092 ///for setting ReachedMap object. 1087 1093 template<class T> 1088 1094 BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) … … 1098 1104 SetDistMapBase(const TR &b) : TR(b) {} 1099 1105 }; 1100 1101 ///\brief \ref named-templ-param "Named parameter" for setting 1102 ///the distance map. 1103 /// 1104 ///\ref named-templ-param "Named parameter" function for setting 1105 ///the map that stores the distances of the nodes calculated 1106 ///by the algorithm. 1106 ///\brief \ref named-func-param "Named parameter" 1107 ///for setting DistMap object. 1108 /// 1109 /// \ref named-func-param "Named parameter" 1110 ///for setting DistMap object. 1107 1111 template<class T> 1108 1112 BfsWizard<SetDistMapBase<T> > distMap(const T &t) … … 1118 1122 SetProcessedMapBase(const TR &b) : TR(b) {} 1119 1123 }; 1120 1121 ///\brief \ref named-func-param "Named parameter" for setting 1122 ///the processed map. 1123 /// 1124 ///\ref named-templ-param "Named parameter" function for setting 1125 ///the map that indicates which nodes are processed. 1124 ///\brief \ref named-func-param "Named parameter" 1125 ///for setting ProcessedMap object. 1126 /// 1127 /// \ref named-func-param "Named parameter" 1128 ///for setting ProcessedMap object. 1126 1129 template<class T> 1127 1130 BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1262 1265 /// 1263 1266 /// The type of the map that indicates which nodes are reached. 1264 /// It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.1267 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 1265 1268 typedef typename Digraph::template NodeMap<bool> ReachedMap; 1266 1269 … … 1423 1426 /// The simplest way to execute the BFS algorithm is to use one of the 1424 1427 /// member functions called \ref run(Node) "run()".\n 1425 /// If you need better control on the execution,you have to call1426 /// \ref init() first, then you can add several source nodes with1428 /// If you need more control on the execution, first you have to call 1429 /// \ref init(), then you can add several source nodes with 1427 1430 /// \ref addSource(). Finally the actual path computation can be 1428 1431 /// performed with one of the \ref start() functions. … … 1733 1736 ///@{ 1734 1737 1735 /// \brief Checks if the givennode is reached from the root(s).1738 /// \brief Checks if a node is reached from the root(s). 1736 1739 /// 1737 1740 /// Returns \c true if \c v is reached from the root(s). -
lemon/bin_heap.h
r758 r730 20 20 #define LEMON_BIN_HEAP_H 21 21 22 ///\ingroup heaps22 ///\ingroup auxdat 23 23 ///\file 24 ///\brief Binary heap implementation.24 ///\brief Binary Heap implementation. 25 25 26 26 #include <vector> … … 30 30 namespace lemon { 31 31 32 /// \ingroup heaps 33 /// 34 /// \brief Binary heap data structure. 35 /// 36 /// This class implements the \e binary \e heap data structure. 37 /// It fully conforms to the \ref concepts::Heap "heap concept". 38 /// 39 /// \tparam PR Type of the priorities of the items. 40 /// \tparam IM A read-writable item map with \c int values, used 41 /// internally to handle the cross references. 42 /// \tparam CMP A functor class for comparing the priorities. 43 /// The default is \c std::less<PR>. 44 #ifdef DOXYGEN 45 template <typename PR, typename IM, typename CMP> 46 #else 32 ///\ingroup auxdat 33 /// 34 ///\brief A Binary Heap implementation. 35 /// 36 ///This class implements the \e binary \e heap data structure. 37 /// 38 ///A \e heap is a data structure for storing items with specified values 39 ///called \e priorities in such a way that finding the item with minimum 40 ///priority is efficient. \c CMP specifies the ordering of the priorities. 41 ///In a heap one can change the priority of an item, add or erase an 42 ///item, etc. 43 /// 44 ///\tparam PR Type of the priority of the items. 45 ///\tparam IM A read and writable item map with int values, used internally 46 ///to handle the cross references. 47 ///\tparam CMP A functor class for the ordering of the priorities. 48 ///The default is \c std::less<PR>. 49 /// 50 ///\sa FibHeap 51 ///\sa Dijkstra 47 52 template <typename PR, typename IM, typename CMP = std::less<PR> > 48 #endif49 53 class BinHeap { 54 50 55 public: 51 52 /// Type of the item-int map. 56 ///\e 53 57 typedef IM ItemIntMap; 54 /// Type of the priorities.58 ///\e 55 59 typedef PR Prio; 56 /// Type of the items stored in the heap.60 ///\e 57 61 typedef typename ItemIntMap::Key Item; 58 /// Type of the item-priority pairs.62 ///\e 59 63 typedef std::pair<Item,Prio> Pair; 60 /// Functor type for comparing the priorities.64 ///\e 61 65 typedef CMP Compare; 62 66 63 /// \brief Type to represent the states of the items.64 /// 65 /// Each item has a state associated to it. It canbe "in heap",66 /// "pre -heap" or "post-heap". The latter two are indifferent from the67 /// \brief Type to represent the items states. 68 /// 69 /// Each Item element have a state associated to it. It may be "in heap", 70 /// "pre heap" or "post heap". The latter two are indifferent from the 67 71 /// heap's point of view, but may be useful to the user. 68 72 /// … … 81 85 82 86 public: 83 84 /// \brief Constructor. 85 /// 86 /// Constructor. 87 /// \param map A map that assigns \c int values to the items. 88 /// It is used internally to handle the cross references. 89 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 87 /// \brief The constructor. 88 /// 89 /// The constructor. 90 /// \param map should be given to the constructor, since it is used 91 /// internally to handle the cross references. The value of the map 92 /// must be \c PRE_HEAP (<tt>-1</tt>) for every item. 90 93 explicit BinHeap(ItemIntMap &map) : _iim(map) {} 91 94 92 /// \brief Constructor. 93 /// 94 /// Constructor. 95 /// \param map A map that assigns \c int values to the items. 96 /// It is used internally to handle the cross references. 97 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 98 /// \param comp The function object used for comparing the priorities. 95 /// \brief The constructor. 96 /// 97 /// The constructor. 98 /// \param map should be given to the constructor, since it is used 99 /// internally to handle the cross references. The value of the map 100 /// should be PRE_HEAP (-1) for each element. 101 /// 102 /// \param comp The comparator function object. 99 103 BinHeap(ItemIntMap &map, const Compare &comp) 100 104 : _iim(map), _comp(comp) {} 101 105 102 106 103 /// \briefThe number of items stored in the heap.104 /// 105 /// This function returns the number of items stored in the heap.107 /// The number of items stored in the heap. 108 /// 109 /// \brief Returns the number of items stored in the heap. 106 110 int size() const { return _data.size(); } 107 111 108 /// \brief Check if the heap is empty.109 /// 110 /// This function returns \c true if the heap is empty.112 /// \brief Checks if the heap stores no items. 113 /// 114 /// Returns \c true if and only if the heap stores no items. 111 115 bool empty() const { return _data.empty(); } 112 116 113 /// \brief Make the heap empty. 114 /// 115 /// This functon makes the heap empty. 116 /// It does not change the cross reference map. If you want to reuse 117 /// a heap that is not surely empty, you should first clear it and 118 /// then you should set the cross reference map to \c PRE_HEAP 119 /// for each item. 117 /// \brief Make empty this heap. 118 /// 119 /// Make empty this heap. It does not change the cross reference map. 120 /// If you want to reuse what is not surely empty you should first clear 121 /// the heap and after that you should set the cross reference map for 122 /// each item to \c PRE_HEAP. 120 123 void clear() { 121 124 _data.clear(); … … 125 128 static int parent(int i) { return (i-1)/2; } 126 129 127 static int second Child(int i) { return 2*i+2; }130 static int second_child(int i) { return 2*i+2; } 128 131 bool less(const Pair &p1, const Pair &p2) const { 129 132 return _comp(p1.second, p2.second); 130 133 } 131 134 132 int bubble Up(int hole, Pair p) {135 int bubble_up(int hole, Pair p) { 133 136 int par = parent(hole); 134 137 while( hole>0 && less(p,_data[par]) ) { … … 141 144 } 142 145 143 int bubble Down(int hole, Pair p, int length) {144 int child = second Child(hole);146 int bubble_down(int hole, Pair p, int length) { 147 int child = second_child(hole); 145 148 while(child < length) { 146 149 if( less(_data[child-1], _data[child]) ) { … … 151 154 move(_data[child], hole); 152 155 hole = child; 153 child = second Child(hole);156 child = second_child(hole); 154 157 } 155 158 child--; … … 169 172 170 173 public: 171 172 174 /// \brief Insert a pair of item and priority into the heap. 173 175 /// 174 /// This function inserts \c p.first to the heap with priority 175 /// \c p.second. 176 /// Adds \c p.first to the heap with priority \c p.second. 176 177 /// \param p The pair to insert. 177 /// \pre \c p.first must not be stored in the heap.178 178 void push(const Pair &p) { 179 179 int n = _data.size(); 180 180 _data.resize(n+1); 181 bubbleUp(n, p); 182 } 183 184 /// \brief Insert an item into the heap with the given priority. 185 /// 186 /// This function inserts the given item into the heap with the 187 /// given priority. 181 bubble_up(n, p); 182 } 183 184 /// \brief Insert an item into the heap with the given heap. 185 /// 186 /// Adds \c i to the heap with priority \c p. 188 187 /// \param i The item to insert. 189 188 /// \param p The priority of the item. 190 /// \pre \e i must not be stored in the heap.191 189 void push(const Item &i, const Prio &p) { push(Pair(i,p)); } 192 190 193 /// \brief Return the item having minimum priority. 194 /// 195 /// This function returns the item having minimum priority. 196 /// \pre The heap must be non-empty. 191 /// \brief Returns the item with minimum priority relative to \c Compare. 192 /// 193 /// This method returns the item with minimum priority relative to \c 194 /// Compare. 195 /// \pre The heap must be nonempty. 197 196 Item top() const { 198 197 return _data[0].first; 199 198 } 200 199 201 /// \brief The minimum priority.202 /// 203 /// This function returns the minimum priority.204 /// \pre The heap must be non -empty.200 /// \brief Returns the minimum priority relative to \c Compare. 201 /// 202 /// It returns the minimum priority relative to \c Compare. 203 /// \pre The heap must be nonempty. 205 204 Prio prio() const { 206 205 return _data[0].second; 207 206 } 208 207 209 /// \brief Remove the item having minimum priority. 210 /// 211 /// This function removes the item having minimum priority. 208 /// \brief Deletes the item with minimum priority relative to \c Compare. 209 /// 210 /// This method deletes the item with minimum priority relative to \c 211 /// Compare from the heap. 212 212 /// \pre The heap must be non-empty. 213 213 void pop() { … … 215 215 _iim.set(_data[0].first, POST_HEAP); 216 216 if (n > 0) { 217 bubble Down(0, _data[n], n);217 bubble_down(0, _data[n], n); 218 218 } 219 219 _data.pop_back(); 220 220 } 221 221 222 /// \brief Remove the given item from the heap. 223 /// 224 /// This function removes the given item from the heap if it is 225 /// already stored. 226 /// \param i The item to delete. 227 /// \pre \e i must be in the heap. 222 /// \brief Deletes \c i from the heap. 223 /// 224 /// This method deletes item \c i from the heap. 225 /// \param i The item to erase. 226 /// \pre The item should be in the heap. 228 227 void erase(const Item &i) { 229 228 int h = _iim[i]; … … 231 230 _iim.set(_data[h].first, POST_HEAP); 232 231 if( h < n ) { 233 if ( bubble Up(h, _data[n]) == h) {234 bubble Down(h, _data[n], n);232 if ( bubble_up(h, _data[n]) == h) { 233 bubble_down(h, _data[n], n); 235 234 } 236 235 } … … 238 237 } 239 238 240 /// \brief The priority of the given item. 241 /// 242 /// This function returns the priority of the given item. 243 /// \param i The item. 244 /// \pre \e i must be in the heap. 239 240 /// \brief Returns the priority of \c i. 241 /// 242 /// This function returns the priority of item \c i. 243 /// \param i The item. 244 /// \pre \c i must be in the heap. 245 245 Prio operator[](const Item &i) const { 246 246 int idx = _iim[i]; … … 248 248 } 249 249 250 /// \brief Set the priority of an item or insert it, if it is 251 /// not stored in the heap. 252 /// 253 /// This method sets the priority of the given item if it is 254 /// already stored in the heap. Otherwise it inserts the given 255 /// item into the heap with the given priority. 250 /// \brief \c i gets to the heap with priority \c p independently 251 /// if \c i was already there. 252 /// 253 /// This method calls \ref push(\c i, \c p) if \c i is not stored 254 /// in the heap and sets the priority of \c i to \c p otherwise. 256 255 /// \param i The item. 257 256 /// \param p The priority. … … 262 261 } 263 262 else if( _comp(p, _data[idx].second) ) { 264 bubble Up(idx, Pair(i,p));263 bubble_up(idx, Pair(i,p)); 265 264 } 266 265 else { 267 bubble Down(idx, Pair(i,p), _data.size());268 } 269 } 270 271 /// \brief Decrease the priority of an item to the given value.272 /// 273 /// This function decreases the priority of an item to the given value.266 bubble_down(idx, Pair(i,p), _data.size()); 267 } 268 } 269 270 /// \brief Decreases the priority of \c i to \c p. 271 /// 272 /// This method decreases the priority of item \c i to \c p. 274 273 /// \param i The item. 275 274 /// \param p The priority. 276 /// \pre \e i must be stored in the heap with priority at least \e p. 275 /// \pre \c i must be stored in the heap with priority at least \c 276 /// p relative to \c Compare. 277 277 void decrease(const Item &i, const Prio &p) { 278 278 int idx = _iim[i]; 279 bubble Up(idx, Pair(i,p));280 } 281 282 /// \brief Increase the priority of an item to the given value.283 /// 284 /// This function increases the priority of an item to the given value.279 bubble_up(idx, Pair(i,p)); 280 } 281 282 /// \brief Increases the priority of \c i to \c p. 283 /// 284 /// This method sets the priority of item \c i to \c p. 285 285 /// \param i The item. 286 286 /// \param p The priority. 287 /// \pre \e i must be stored in the heap with priority at most \e p. 287 /// \pre \c i must be stored in the heap with priority at most \c 288 /// p relative to \c Compare. 288 289 void increase(const Item &i, const Prio &p) { 289 290 int idx = _iim[i]; 290 bubble Down(idx, Pair(i,p), _data.size());291 } 292 293 /// \brief Return the state of an item.294 /// 295 /// This method returns \c PRE_HEAP if the given item has never296 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,297 /// and \c POST_HEAP otherwise.298 /// In the latter case it is possible that the item will get back299 /// to the heap again.291 bubble_down(idx, Pair(i,p), _data.size()); 292 } 293 294 /// \brief Returns if \c item is in, has already been in, or has 295 /// never been in the heap. 296 /// 297 /// This method returns PRE_HEAP if \c item has never been in the 298 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 299 /// otherwise. In the latter case it is possible that \c item will 300 /// get back to the heap again. 300 301 /// \param i The item. 301 302 State state(const Item &i) const { … … 306 307 } 307 308 308 /// \brief Set the state of anitem in the heap.309 /// 310 /// This function sets the state of the given item in the heap.311 /// It can be used to manually clear the heap when it is important312 /// to achivebetter time complexity.309 /// \brief Sets the state of the \c item in the heap. 310 /// 311 /// Sets the state of the \c item in the heap. It can be used to 312 /// manually clear the heap when it is important to achive the 313 /// better time complexity. 313 314 /// \param i The item. 314 315 /// \param st The state. It should not be \c IN_HEAP. … … 327 328 } 328 329 329 /// \brief Replace an item in the heap. 330 /// 331 /// This function replaces item \c i with item \c j. 332 /// Item \c i must be in the heap, while \c j must be out of the heap. 333 /// After calling this method, item \c i will be out of the 334 /// heap and \c j will be in the heap with the same prioriority 335 /// as item \c i had before. 330 /// \brief Replaces an item in the heap. 331 /// 332 /// The \c i item is replaced with \c j item. The \c i item should 333 /// be in the heap, while the \c j should be out of the heap. The 334 /// \c i item will out of the heap and \c j will be in the heap 335 /// with the same prioriority as prevoiusly the \c i item. 336 336 void replace(const Item& i, const Item& j) { 337 337 int idx = _iim[i]; -
lemon/bits/map_extender.h
r765 r664 50 50 typedef typename Parent::ConstReference ConstReference; 51 51 52 typedef typename Parent::ReferenceMapTag ReferenceMapTag;53 54 52 class MapIt; 55 53 class ConstMapIt; … … 194 192 typedef typename Parent::ConstReference ConstReference; 195 193 196 typedef typename Parent::ReferenceMapTag ReferenceMapTag;197 198 194 class MapIt; 199 195 class ConstMapIt; -
lemon/bucket_heap.h
r758 r730 20 20 #define LEMON_BUCKET_HEAP_H 21 21 22 ///\ingroup heaps22 ///\ingroup auxdat 23 23 ///\file 24 ///\brief Bucket heap implementation.24 ///\brief Bucket Heap implementation. 25 25 26 26 #include <vector> … … 54 54 } 55 55 56 /// \ingroup heaps 57 /// 58 /// \brief Bucket heap data structure. 59 /// 60 /// This class implements the \e bucket \e heap data structure. 61 /// It practically conforms to the \ref concepts::Heap "heap concept", 62 /// but it has some limitations. 63 /// 64 /// The bucket heap is a very simple structure. It can store only 65 /// \c int priorities and it maintains a list of items for each priority 66 /// in the range <tt>[0..C)</tt>. So it should only be used when the 67 /// priorities are small. It is not intended to use as a Dijkstra heap. 68 /// 69 /// \tparam IM A read-writable item map with \c int values, used 70 /// internally to handle the cross references. 71 /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. 72 /// The default is \e min-heap. If this parameter is set to \c false, 73 /// then the comparison is reversed, so the top(), prio() and pop() 74 /// functions deal with the item having maximum priority instead of the 75 /// minimum. 76 /// 77 /// \sa SimpleBucketHeap 56 /// \ingroup auxdat 57 /// 58 /// \brief A Bucket Heap implementation. 59 /// 60 /// This class implements the \e bucket \e heap data structure. A \e heap 61 /// is a data structure for storing items with specified values called \e 62 /// priorities in such a way that finding the item with minimum priority is 63 /// efficient. The bucket heap is very simple implementation, it can store 64 /// only integer priorities and it stores for each priority in the 65 /// \f$ [0..C) \f$ range a list of items. So it should be used only when 66 /// the priorities are small. It is not intended to use as dijkstra heap. 67 /// 68 /// \param IM A read and write Item int map, used internally 69 /// to handle the cross references. 70 /// \param MIN If the given parameter is false then instead of the 71 /// minimum value the maximum can be retrivied with the top() and 72 /// prio() member functions. 78 73 template <typename IM, bool MIN = true> 79 74 class BucketHeap { 80 75 81 76 public: 82 83 /// Type of the item-int map. 77 /// \e 78 typedef typename IM::Key Item; 79 /// \e 80 typedef int Prio; 81 /// \e 82 typedef std::pair<Item, Prio> Pair; 83 /// \e 84 84 typedef IM ItemIntMap; 85 /// Type of the priorities.86 typedef int Prio;87 /// Type of the items stored in the heap.88 typedef typename ItemIntMap::Key Item;89 /// Type of the item-priority pairs.90 typedef std::pair<Item,Prio> Pair;91 85 92 86 private: … … 96 90 public: 97 91 98 /// \brief Type to represent the states of the items.99 /// 100 /// Each item has a state associated to it. It canbe "in heap",101 /// "pre -heap" or "post-heap". The latter two are indifferent from the92 /// \brief Type to represent the items states. 93 /// 94 /// Each Item element have a state associated to it. It may be "in heap", 95 /// "pre heap" or "post heap". The latter two are indifferent from the 102 96 /// heap's point of view, but may be useful to the user. 103 97 /// … … 111 105 112 106 public: 113 114 /// \brief Constructor. 115 /// 116 /// Constructor. 117 /// \param map A map that assigns \c int values to the items. 118 /// It is used internally to handle the cross references. 119 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 107 /// \brief The constructor. 108 /// 109 /// The constructor. 110 /// \param map should be given to the constructor, since it is used 111 /// internally to handle the cross references. The value of the map 112 /// should be PRE_HEAP (-1) for each element. 120 113 explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} 121 114 122 /// \briefThe number of items stored in the heap.123 /// 124 /// This function returns the number of items stored in the heap.115 /// The number of items stored in the heap. 116 /// 117 /// \brief Returns the number of items stored in the heap. 125 118 int size() const { return _data.size(); } 126 119 127 /// \brief Check if the heap is empty.128 /// 129 /// This function returns \c true if the heap is empty.120 /// \brief Checks if the heap stores no items. 121 /// 122 /// Returns \c true if and only if the heap stores no items. 130 123 bool empty() const { return _data.empty(); } 131 124 132 /// \brief Make the heap empty. 133 /// 134 /// This functon makes the heap empty. 135 /// It does not change the cross reference map. If you want to reuse 136 /// a heap that is not surely empty, you should first clear it and 137 /// then you should set the cross reference map to \c PRE_HEAP 138 /// for each item. 125 /// \brief Make empty this heap. 126 /// 127 /// Make empty this heap. It does not change the cross reference 128 /// map. If you want to reuse a heap what is not surely empty you 129 /// should first clear the heap and after that you should set the 130 /// cross reference map for each item to \c PRE_HEAP. 139 131 void clear() { 140 132 _data.clear(); _first.clear(); _minimum = 0; … … 143 135 private: 144 136 145 void relocate Last(int idx) {137 void relocate_last(int idx) { 146 138 if (idx + 1 < int(_data.size())) { 147 139 _data[idx] = _data.back(); … … 183 175 184 176 public: 185 186 177 /// \brief Insert a pair of item and priority into the heap. 187 178 /// 188 /// This function inserts \c p.first to the heap with priority 189 /// \c p.second. 179 /// Adds \c p.first to the heap with priority \c p.second. 190 180 /// \param p The pair to insert. 191 /// \pre \c p.first must not be stored in the heap.192 181 void push(const Pair& p) { 193 182 push(p.first, p.second); … … 196 185 /// \brief Insert an item into the heap with the given priority. 197 186 /// 198 /// This function inserts the given item into the heap with the 199 /// given priority. 187 /// Adds \c i to the heap with priority \c p. 200 188 /// \param i The item to insert. 201 189 /// \param p The priority of the item. 202 /// \pre \e i must not be stored in the heap.203 190 void push(const Item &i, const Prio &p) { 204 191 int idx = _data.size(); … … 211 198 } 212 199 213 /// \brief Return the item havingminimum priority.214 /// 215 /// This function returns the item havingminimum priority.216 /// \pre The heap must be non -empty.200 /// \brief Returns the item with minimum priority. 201 /// 202 /// This method returns the item with minimum priority. 203 /// \pre The heap must be nonempty. 217 204 Item top() const { 218 205 while (_first[_minimum] == -1) { … … 222 209 } 223 210 224 /// \brief The minimum priority.225 /// 226 /// This functionreturns the minimum priority.227 /// \pre The heap must be non -empty.211 /// \brief Returns the minimum priority. 212 /// 213 /// It returns the minimum priority. 214 /// \pre The heap must be nonempty. 228 215 Prio prio() const { 229 216 while (_first[_minimum] == -1) { … … 233 220 } 234 221 235 /// \brief Remove the item havingminimum priority.236 /// 237 /// This function removes the item having minimum priority.222 /// \brief Deletes the item with minimum priority. 223 /// 224 /// This method deletes the item with minimum priority from the heap. 238 225 /// \pre The heap must be non-empty. 239 226 void pop() { … … 244 231 _iim[_data[idx].item] = -2; 245 232 unlace(idx); 246 relocateLast(idx); 247 } 248 249 /// \brief Remove the given item from the heap. 250 /// 251 /// This function removes the given item from the heap if it is 252 /// already stored. 253 /// \param i The item to delete. 254 /// \pre \e i must be in the heap. 233 relocate_last(idx); 234 } 235 236 /// \brief Deletes \c i from the heap. 237 /// 238 /// This method deletes item \c i from the heap, if \c i was 239 /// already stored in the heap. 240 /// \param i The item to erase. 255 241 void erase(const Item &i) { 256 242 int idx = _iim[i]; 257 243 _iim[_data[idx].item] = -2; 258 244 unlace(idx); 259 relocateLast(idx); 260 } 261 262 /// \brief The priority of the given item. 263 /// 264 /// This function returns the priority of the given item. 265 /// \param i The item. 266 /// \pre \e i must be in the heap. 245 relocate_last(idx); 246 } 247 248 249 /// \brief Returns the priority of \c i. 250 /// 251 /// This function returns the priority of item \c i. 252 /// \pre \c i must be in the heap. 253 /// \param i The item. 267 254 Prio operator[](const Item &i) const { 268 255 int idx = _iim[i]; … … 270 257 } 271 258 272 /// \brief Set the priority of an item or insert it, if it is 273 /// not stored in the heap. 274 /// 275 /// This method sets the priority of the given item if it is 276 /// already stored in the heap. Otherwise it inserts the given 277 /// item into the heap with the given priority. 259 /// \brief \c i gets to the heap with priority \c p independently 260 /// if \c i was already there. 261 /// 262 /// This method calls \ref push(\c i, \c p) if \c i is not stored 263 /// in the heap and sets the priority of \c i to \c p otherwise. 278 264 /// \param i The item. 279 265 /// \param p The priority. … … 289 275 } 290 276 291 /// \brief Decrease the priority of an item to the given value. 292 /// 293 /// This function decreases the priority of an item to the given value. 277 /// \brief Decreases the priority of \c i to \c p. 278 /// 279 /// This method decreases the priority of item \c i to \c p. 280 /// \pre \c i must be stored in the heap with priority at least \c 281 /// p relative to \c Compare. 294 282 /// \param i The item. 295 283 /// \param p The priority. 296 /// \pre \e i must be stored in the heap with priority at least \e p.297 284 void decrease(const Item &i, const Prio &p) { 298 285 int idx = _iim[i]; … … 305 292 } 306 293 307 /// \brief Increase the priority of an item to the given value. 308 /// 309 /// This function increases the priority of an item to the given value. 294 /// \brief Increases the priority of \c i to \c p. 295 /// 296 /// This method sets the priority of item \c i to \c p. 297 /// \pre \c i must be stored in the heap with priority at most \c 298 /// p relative to \c Compare. 310 299 /// \param i The item. 311 300 /// \param p The priority. 312 /// \pre \e i must be stored in the heap with priority at most \e p.313 301 void increase(const Item &i, const Prio &p) { 314 302 int idx = _iim[i]; … … 318 306 } 319 307 320 /// \brief Return the state of an item.321 /// 322 /// This method returns \c PRE_HEAP if the given item has never323 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,324 /// and \c POST_HEAP otherwise.325 /// In the latter case it is possible that the item will get back326 /// to the heap again.308 /// \brief Returns if \c item is in, has already been in, or has 309 /// never been in the heap. 310 /// 311 /// This method returns PRE_HEAP if \c item has never been in the 312 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 313 /// otherwise. In the latter case it is possible that \c item will 314 /// get back to the heap again. 327 315 /// \param i The item. 328 316 State state(const Item &i) const { … … 332 320 } 333 321 334 /// \brief Set the state of anitem in the heap.335 /// 336 /// This function sets the state of the given item in the heap.337 /// It can be used to manually clear the heap when it is important338 /// to achivebetter time complexity.322 /// \brief Sets the state of the \c item in the heap. 323 /// 324 /// Sets the state of the \c item in the heap. It can be used to 325 /// manually clear the heap when it is important to achive the 326 /// better time complexity. 339 327 /// \param i The item. 340 328 /// \param st The state. It should not be \c IN_HEAP. … … 372 360 }; // class BucketHeap 373 361 374 /// \ingroup heaps375 /// 376 /// \brief Simplified bucket heap data structure.362 /// \ingroup auxdat 363 /// 364 /// \brief A Simplified Bucket Heap implementation. 377 365 /// 378 366 /// This class implements a simplified \e bucket \e heap data 379 /// structure. It does not provide some functionality, but it is 380 /// faster and simpler than BucketHeap. The main difference is 381 /// that BucketHeap stores a doubly-linked list for each key while 382 /// this class stores only simply-linked lists. It supports erasing 383 /// only for the item having minimum priority and it does not support 384 /// key increasing and decreasing. 385 /// 386 /// Note that this implementation does not conform to the 387 /// \ref concepts::Heap "heap concept" due to the lack of some 388 /// functionality. 389 /// 390 /// \tparam IM A read-writable item map with \c int values, used 391 /// internally to handle the cross references. 392 /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap. 393 /// The default is \e min-heap. If this parameter is set to \c false, 394 /// then the comparison is reversed, so the top(), prio() and pop() 395 /// functions deal with the item having maximum priority instead of the 396 /// minimum. 367 /// structure. It does not provide some functionality but it faster 368 /// and simplier data structure than the BucketHeap. The main 369 /// difference is that the BucketHeap stores for every key a double 370 /// linked list while this class stores just simple lists. In the 371 /// other way it does not support erasing each elements just the 372 /// minimal and it does not supports key increasing, decreasing. 373 /// 374 /// \param IM A read and write Item int map, used internally 375 /// to handle the cross references. 376 /// \param MIN If the given parameter is false then instead of the 377 /// minimum value the maximum can be retrivied with the top() and 378 /// prio() member functions. 397 379 /// 398 380 /// \sa BucketHeap … … 401 383 402 384 public: 403 404 /// Type of the item-int map. 385 typedef typename IM::Key Item; 386 typedef int Prio; 387 typedef std::pair<Item, Prio> Pair; 405 388 typedef IM ItemIntMap; 406 /// Type of the priorities.407 typedef int Prio;408 /// Type of the items stored in the heap.409 typedef typename ItemIntMap::Key Item;410 /// Type of the item-priority pairs.411 typedef std::pair<Item,Prio> Pair;412 389 413 390 private: … … 417 394 public: 418 395 419 /// \brief Type to represent the states of the items.420 /// 421 /// Each item has a state associated to it. It canbe "in heap",422 /// "pre -heap" or "post-heap". The latter two are indifferent from the396 /// \brief Type to represent the items states. 397 /// 398 /// Each Item element have a state associated to it. It may be "in heap", 399 /// "pre heap" or "post heap". The latter two are indifferent from the 423 400 /// heap's point of view, but may be useful to the user. 424 401 /// … … 433 410 public: 434 411 435 /// \brief Constructor.436 /// 437 /// Constructor.438 /// \param map A map that assigns \c int values to the items.439 /// It is used internally to handle the cross references.440 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.412 /// \brief The constructor. 413 /// 414 /// The constructor. 415 /// \param map should be given to the constructor, since it is used 416 /// internally to handle the cross references. The value of the map 417 /// should be PRE_HEAP (-1) for each element. 441 418 explicit SimpleBucketHeap(ItemIntMap &map) 442 419 : _iim(map), _free(-1), _num(0), _minimum(0) {} 443 420 444 /// \brief The number of items stored in the heap.445 /// 446 /// Th is function returns the number of items stored in the heap.421 /// \brief Returns the number of items stored in the heap. 422 /// 423 /// The number of items stored in the heap. 447 424 int size() const { return _num; } 448 425 449 /// \brief Check if the heap is empty.450 /// 451 /// This function returns \c true if the heap is empty.426 /// \brief Checks if the heap stores no items. 427 /// 428 /// Returns \c true if and only if the heap stores no items. 452 429 bool empty() const { return _num == 0; } 453 430 454 /// \brief Make the heap empty. 455 /// 456 /// This functon makes the heap empty. 457 /// It does not change the cross reference map. If you want to reuse 458 /// a heap that is not surely empty, you should first clear it and 459 /// then you should set the cross reference map to \c PRE_HEAP 460 /// for each item. 431 /// \brief Make empty this heap. 432 /// 433 /// Make empty this heap. It does not change the cross reference 434 /// map. If you want to reuse a heap what is not surely empty you 435 /// should first clear the heap and after that you should set the 436 /// cross reference map for each item to \c PRE_HEAP. 461 437 void clear() { 462 438 _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; … … 465 441 /// \brief Insert a pair of item and priority into the heap. 466 442 /// 467 /// This function inserts \c p.first to the heap with priority 468 /// \c p.second. 443 /// Adds \c p.first to the heap with priority \c p.second. 469 444 /// \param p The pair to insert. 470 /// \pre \c p.first must not be stored in the heap.471 445 void push(const Pair& p) { 472 446 push(p.first, p.second); … … 475 449 /// \brief Insert an item into the heap with the given priority. 476 450 /// 477 /// This function inserts the given item into the heap with the 478 /// given priority. 451 /// Adds \c i to the heap with priority \c p. 479 452 /// \param i The item to insert. 480 453 /// \param p The priority of the item. 481 /// \pre \e i must not be stored in the heap.482 454 void push(const Item &i, const Prio &p) { 483 455 int idx; … … 500 472 } 501 473 502 /// \brief Return the item havingminimum priority.503 /// 504 /// This function returns the item havingminimum priority.505 /// \pre The heap must be non -empty.474 /// \brief Returns the item with minimum priority. 475 /// 476 /// This method returns the item with minimum priority. 477 /// \pre The heap must be nonempty. 506 478 Item top() const { 507 479 while (_first[_minimum] == -1) { … … 511 483 } 512 484 513 /// \brief The minimum priority.514 /// 515 /// This functionreturns the minimum priority.516 /// \pre The heap must be non -empty.485 /// \brief Returns the minimum priority. 486 /// 487 /// It returns the minimum priority. 488 /// \pre The heap must be nonempty. 517 489 Prio prio() const { 518 490 while (_first[_minimum] == -1) { … … 522 494 } 523 495 524 /// \brief Remove the item havingminimum priority.525 /// 526 /// This function removes the item having minimum priority.496 /// \brief Deletes the item with minimum priority. 497 /// 498 /// This method deletes the item with minimum priority from the heap. 527 499 /// \pre The heap must be non-empty. 528 500 void pop() { … … 538 510 } 539 511 540 /// \brief The priority of the given item. 541 /// 542 /// This function returns the priority of the given item. 543 /// \param i The item. 544 /// \pre \e i must be in the heap. 545 /// \warning This operator is not a constant time function because 546 /// it scans the whole data structure to find the proper value. 512 /// \brief Returns the priority of \c i. 513 /// 514 /// This function returns the priority of item \c i. 515 /// \warning This operator is not a constant time function 516 /// because it scans the whole data structure to find the proper 517 /// value. 518 /// \pre \c i must be in the heap. 519 /// \param i The item. 547 520 Prio operator[](const Item &i) const { 548 for (int k = 0; k < int(_first.size()); ++k) {521 for (int k = 0; k < _first.size(); ++k) { 549 522 int idx = _first[k]; 550 523 while (idx != -1) { … … 558 531 } 559 532 560 /// \brief Return the state of an item.561 /// 562 /// This method returns \c PRE_HEAP if the given item has never563 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,564 /// and \c POST_HEAP otherwise.565 /// In the latter case it is possible that the item will get back566 /// to the heap again.533 /// \brief Returns if \c item is in, has already been in, or has 534 /// never been in the heap. 535 /// 536 /// This method returns PRE_HEAP if \c item has never been in the 537 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 538 /// otherwise. In the latter case it is possible that \c item will 539 /// get back to the heap again. 567 540 /// \param i The item. 568 541 State state(const Item &i) const { -
lemon/cbc.cc
r793 r623 95 95 } 96 96 97 int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {98 std::vector<int> indexes;99 std::vector<Value> values;100 101 for(ExprIterator it = b; it != e; ++it) {102 indexes.push_back(it->first);103 values.push_back(it->second);104 }105 106 _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);107 return _prob->numberRows() - 1;108 }109 97 110 98 void CbcMip::_eraseCol(int i) { -
lemon/cbc.h
r793 r623 63 63 virtual int _addCol(); 64 64 virtual int _addRow(); 65 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);66 65 67 66 virtual void _eraseCol(int i); -
lemon/circulation.h
r762 r688 73 73 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" 74 74 /// concept. 75 #ifdef DOXYGEN76 typedef GR::ArcMap<Value> FlowMap;77 #else78 75 typedef typename Digraph::template ArcMap<Value> FlowMap; 79 #endif80 76 81 77 /// \brief Instantiates a FlowMap. … … 92 88 /// The elevator type used by the algorithm. 93 89 /// 94 /// \sa Elevator, LinkedElevator 95 #ifdef DOXYGEN 96 typedef lemon::Elevator<GR, GR::Node> Elevator; 97 #else 90 /// \sa Elevator 91 /// \sa LinkedElevator 98 92 typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator; 99 #endif100 93 101 94 /// \brief Instantiates an Elevator. … … 458 451 } 459 452 460 /// \brief Sets the tolerance used by the algorithm. 461 /// 462 /// Sets the tolerance object used by the algorithm. 463 /// \return <tt>(*this)</tt> 464 Circulation& tolerance(const Tolerance& tolerance) { 453 /// \brief Sets the tolerance used by algorithm. 454 /// 455 /// Sets the tolerance used by algorithm. 456 Circulation& tolerance(const Tolerance& tolerance) const { 465 457 _tol = tolerance; 466 458 return *this; … … 469 461 /// \brief Returns a const reference to the tolerance. 470 462 /// 471 /// Returns a const reference to the tolerance object used by 472 /// the algorithm. 463 /// Returns a const reference to the tolerance. 473 464 const Tolerance& tolerance() const { 474 return _tol;465 return tolerance; 475 466 } 476 467 477 468 /// \name Execution Control 478 469 /// The simplest way to execute the algorithm is to call \ref run().\n 479 /// If you need bettercontrol on the initial solution or the execution,480 /// you have to call one of the \ref init() functions first, then470 /// If you need more control on the initial solution or the execution, 471 /// first you have to call one of the \ref init() functions, then 481 472 /// the \ref start() function. 482 473 -
lemon/clp.cc
r793 r623 79 79 } 80 80 81 int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {82 std::vector<int> indexes;83 std::vector<Value> values;84 85 for(ExprIterator it = b; it != e; ++it) {86 indexes.push_back(it->first);87 values.push_back(it->second);88 }89 90 _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);91 return _prob->numberRows() - 1;92 }93 94 81 95 82 void ClpLp::_eraseCol(int c) { -
lemon/clp.h
r793 r623 76 76 virtual int _addCol(); 77 77 virtual int _addRow(); 78 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);79 78 80 79 virtual void _eraseCol(int i); -
lemon/concepts/digraph.h
r781 r627 36 36 /// \brief Class describing the concept of directed graphs. 37 37 /// 38 /// This class describes the common interface of all directed39 /// graphs (digraphs).38 /// This class describes the \ref concept "concept" of the 39 /// immutable directed digraphs. 40 40 /// 41 /// Like all concept classes, it only provides an interface 42 /// without any sensible implementation. So any general algorithm for 43 /// directed graphs should compile with this class, but it will not 44 /// run properly, of course. 45 /// An actual digraph implementation like \ref ListDigraph or 46 /// \ref SmartDigraph may have additional functionality. 41 /// Note that actual digraph implementation like @ref ListDigraph or 42 /// @ref SmartDigraph may have several additional functionality. 47 43 /// 48 /// \sa Graph44 /// \sa concept 49 45 class Digraph { 50 46 private: 51 /// Diraphs are \e not copy constructible. Use DigraphCopy instead. 52 Digraph(const Digraph &) {} 53 /// \brief Assignment of a digraph to another one is \e not allowed. 54 /// Use DigraphCopy instead. 47 ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. 48 49 ///Digraphs are \e not copy constructible. Use DigraphCopy() instead. 50 /// 51 Digraph(const Digraph &) {}; 52 ///\brief Assignment of \ref Digraph "Digraph"s to another ones are 53 ///\e not allowed. Use DigraphCopy() instead. 54 55 ///Assignment of \ref Digraph "Digraph"s to another ones are 56 ///\e not allowed. Use DigraphCopy() instead. 57 55 58 void operator=(const Digraph &) {} 56 57 59 public: 58 /// Default constructor. 60 ///\e 61 62 /// Defalult constructor. 63 64 /// Defalult constructor. 65 /// 59 66 Digraph() { } 60 61 /// The node type of the digraph 67 /// Class for identifying a node of the digraph 62 68 63 69 /// This class identifies a node of the digraph. It also serves 64 70 /// as a base class of the node iterators, 65 /// thus they convert to this type.71 /// thus they will convert to this type. 66 72 class Node { 67 73 public: 68 74 /// Default constructor 69 75 70 /// Default constructor.71 /// \warning It sets the objectto an undefined value.76 /// @warning The default constructor sets the iterator 77 /// to an undefined value. 72 78 Node() { } 73 79 /// Copy constructor. … … 77 83 Node(const Node&) { } 78 84 79 /// %Invalid constructor \& conversion.80 81 /// Initializes the objectto be invalid.85 /// Invalid constructor \& conversion. 86 87 /// This constructor initializes the iterator to be invalid. 82 88 /// \sa Invalid for more details. 83 89 Node(Invalid) { } 84 90 /// Equality operator 85 91 86 /// Equality operator.87 ///88 92 /// Two iterators are equal if and only if they point to the 89 /// same object or both are \c INVALID.93 /// same object or both are invalid. 90 94 bool operator==(Node) const { return true; } 91 95 92 96 /// Inequality operator 93 97 94 /// Inequality operator. 98 /// \sa operator==(Node n) 99 /// 95 100 bool operator!=(Node) const { return true; } 96 101 97 102 /// Artificial ordering operator. 98 103 99 /// Artificial ordering operator. 100 /// 101 /// \note This operator only has to define some strict ordering of 102 /// the nodes; this order has nothing to do with the iteration 103 /// ordering of the nodes. 104 /// To allow the use of digraph descriptors as key type in std::map or 105 /// similar associative container we require this. 106 /// 107 /// \note This operator only have to define some strict ordering of 108 /// the items; this order has nothing to do with the iteration 109 /// ordering of the items. 104 110 bool operator<(Node) const { return false; } 105 }; 106 107 /// Iterator class for the nodes. 108 109 /// This iterator goes through each node of the digraph. 111 112 }; 113 114 /// This iterator goes through each node. 115 116 /// This iterator goes through each node. 110 117 /// Its usage is quite simple, for example you can count the number 111 /// of nodes in a digraph \c g of type \c %Digraph like this:118 /// of nodes in digraph \c g of type \c Digraph like this: 112 119 ///\code 113 120 /// int count=0; … … 118 125 /// Default constructor 119 126 120 /// Default constructor.121 /// \warning It sets the iteratorto an undefined value.127 /// @warning The default constructor sets the iterator 128 /// to an undefined value. 122 129 NodeIt() { } 123 130 /// Copy constructor. … … 126 133 /// 127 134 NodeIt(const NodeIt& n) : Node(n) { } 128 /// %Invalid constructor \& conversion.129 130 /// Initialize sthe iterator to be invalid.135 /// Invalid constructor \& conversion. 136 137 /// Initialize the iterator to be invalid. 131 138 /// \sa Invalid for more details. 132 139 NodeIt(Invalid) { } 133 140 /// Sets the iterator to the first node. 134 141 135 /// Sets the iterator to the first node of the given digraph. 136 /// 137 explicit NodeIt(const Digraph&) { } 138 /// Sets the iterator to the given node. 139 140 /// Sets the iterator to the given node of the given digraph. 141 /// 142 /// Sets the iterator to the first node of \c g. 143 /// 144 NodeIt(const Digraph&) { } 145 /// Node -> NodeIt conversion. 146 147 /// Sets the iterator to the node of \c the digraph pointed by 148 /// the trivial iterator. 149 /// This feature necessitates that each time we 150 /// iterate the arc-set, the iteration order is the same. 142 151 NodeIt(const Digraph&, const Node&) { } 143 152 /// Next node. … … 149 158 150 159 151 /// The arc typeof the digraph160 /// Class for identifying an arc of the digraph 152 161 153 162 /// This class identifies an arc of the digraph. It also serves … … 158 167 /// Default constructor 159 168 160 /// Default constructor.161 /// \warning It sets the objectto an undefined value.169 /// @warning The default constructor sets the iterator 170 /// to an undefined value. 162 171 Arc() { } 163 172 /// Copy constructor. … … 166 175 /// 167 176 Arc(const Arc&) { } 168 /// %Invalid constructor \& conversion.169 170 /// Initialize s the objectto be invalid.171 /// \sa Invalid for more details.177 /// Initialize the iterator to be invalid. 178 179 /// Initialize the iterator to be invalid. 180 /// 172 181 Arc(Invalid) { } 173 182 /// Equality operator 174 183 175 /// Equality operator.176 ///177 184 /// Two iterators are equal if and only if they point to the 178 /// same object or both are \c INVALID.185 /// same object or both are invalid. 179 186 bool operator==(Arc) const { return true; } 180 187 /// Inequality operator 181 188 182 /// Inequality operator. 189 /// \sa operator==(Arc n) 190 /// 183 191 bool operator!=(Arc) const { return true; } 184 192 185 193 /// Artificial ordering operator. 186 194 187 /// Artificial ordering operator. 188 /// 189 /// \note This operator only has to define some strict ordering of 190 /// the arcs; this order has nothing to do with the iteration 191 /// ordering of the arcs. 195 /// To allow the use of digraph descriptors as key type in std::map or 196 /// similar associative container we require this. 197 /// 198 /// \note This operator only have to define some strict ordering of 199 /// the items; this order has nothing to do with the iteration 200 /// ordering of the items. 192 201 bool operator<(Arc) const { return false; } 193 202 }; 194 203 195 /// Iterator class forthe outgoing arcs of a node.204 /// This iterator goes trough the outgoing arcs of a node. 196 205 197 206 /// This iterator goes trough the \e outgoing arcs of a certain node … … 199 208 /// Its usage is quite simple, for example you can count the number 200 209 /// of outgoing arcs of a node \c n 201 /// in a digraph \c g of type \c %Digraph as follows.210 /// in digraph \c g of type \c Digraph as follows. 202 211 ///\code 203 212 /// int count=0; 204 /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;213 /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; 205 214 ///\endcode 215 206 216 class OutArcIt : public Arc { 207 217 public: 208 218 /// Default constructor 209 219 210 /// Default constructor.211 /// \warning It sets the iteratorto an undefined value.220 /// @warning The default constructor sets the iterator 221 /// to an undefined value. 212 222 OutArcIt() { } 213 223 /// Copy constructor. … … 216 226 /// 217 227 OutArcIt(const OutArcIt& e) : Arc(e) { } 218 /// %Invalid constructor \& conversion.219 220 /// Initialize sthe iterator to be invalid.221 /// \sa Invalid for more details.228 /// Initialize the iterator to be invalid. 229 230 /// Initialize the iterator to be invalid. 231 /// 222 232 OutArcIt(Invalid) { } 223 /// Sets the iterator to the first outgoing arc.224 225 /// Sets the iterator to the first outgoing arc of the given node.226 /// 233 /// This constructor sets the iterator to the first outgoing arc. 234 235 /// This constructor sets the iterator to the first outgoing arc of 236 /// the node. 227 237 OutArcIt(const Digraph&, const Node&) { } 228 /// Sets the iterator to the given arc. 229 230 /// Sets the iterator to the given arc of the given digraph. 231 /// 238 /// Arc -> OutArcIt conversion 239 240 /// Sets the iterator to the value of the trivial iterator. 241 /// This feature necessitates that each time we 242 /// iterate the arc-set, the iteration order is the same. 232 243 OutArcIt(const Digraph&, const Arc&) { } 233 /// 244 ///Next outgoing arc 234 245 235 246 /// Assign the iterator to the next … … 238 249 }; 239 250 240 /// Iterator class forthe incoming arcs of a node.251 /// This iterator goes trough the incoming arcs of a node. 241 252 242 253 /// This iterator goes trough the \e incoming arcs of a certain node 243 254 /// of a digraph. 244 255 /// Its usage is quite simple, for example you can count the number 245 /// of incoming arcs of a node \c n246 /// in a digraph \c g of type \c %Digraph as follows.256 /// of outgoing arcs of a node \c n 257 /// in digraph \c g of type \c Digraph as follows. 247 258 ///\code 248 259 /// int count=0; 249 /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;260 /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count; 250 261 ///\endcode 262 251 263 class InArcIt : public Arc { 252 264 public: 253 265 /// Default constructor 254 266 255 /// Default constructor.256 /// \warning It sets the iteratorto an undefined value.267 /// @warning The default constructor sets the iterator 268 /// to an undefined value. 257 269 InArcIt() { } 258 270 /// Copy constructor. … … 261 273 /// 262 274 InArcIt(const InArcIt& e) : Arc(e) { } 263 /// %Invalid constructor \& conversion.264 265 /// Initialize sthe iterator to be invalid.266 /// \sa Invalid for more details.275 /// Initialize the iterator to be invalid. 276 277 /// Initialize the iterator to be invalid. 278 /// 267 279 InArcIt(Invalid) { } 268 /// Sets the iterator to thefirst incoming arc.269 270 /// Sets the iterator to the first incoming arc of the given node.271 /// 280 /// This constructor sets the iterator to first incoming arc. 281 282 /// This constructor set the iterator to the first incoming arc of 283 /// the node. 272 284 InArcIt(const Digraph&, const Node&) { } 273 /// Sets the iterator to the given arc. 274 275 /// Sets the iterator to the given arc of the given digraph. 276 /// 285 /// Arc -> InArcIt conversion 286 287 /// Sets the iterator to the value of the trivial iterator \c e. 288 /// This feature necessitates that each time we 289 /// iterate the arc-set, the iteration order is the same. 277 290 InArcIt(const Digraph&, const Arc&) { } 278 291 /// Next incoming arc 279 292 280 /// Assign the iterator to the next 281 /// incoming arc of the corresponding node.293 /// Assign the iterator to the next inarc of the corresponding node. 294 /// 282 295 InArcIt& operator++() { return *this; } 283 296 }; 284 285 /// Iterator class for the arcs. 286 287 /// This iterator goes through each arc of the digraph. 297 /// This iterator goes through each arc. 298 299 /// This iterator goes through each arc of a digraph. 288 300 /// Its usage is quite simple, for example you can count the number 289 /// of arcs in a digraph \c g of type \c %Digraph as follows:301 /// of arcs in a digraph \c g of type \c Digraph as follows: 290 302 ///\code 291 303 /// int count=0; 292 /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;304 /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count; 293 305 ///\endcode 294 306 class ArcIt : public Arc { … … 296 308 /// Default constructor 297 309 298 /// Default constructor.299 /// \warning It sets the iteratorto an undefined value.310 /// @warning The default constructor sets the iterator 311 /// to an undefined value. 300 312 ArcIt() { } 301 313 /// Copy constructor. … … 304 316 /// 305 317 ArcIt(const ArcIt& e) : Arc(e) { } 306 /// %Invalid constructor \& conversion.307 308 /// Initialize sthe iterator to be invalid.309 /// \sa Invalid for more details.318 /// Initialize the iterator to be invalid. 319 320 /// Initialize the iterator to be invalid. 321 /// 310 322 ArcIt(Invalid) { } 311 /// Sets the iterator to the first arc. 312 313 /// Sets the iterator to the first arc of the given digraph. 314 /// 315 explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } 316 /// Sets the iterator to the given arc. 317 318 /// Sets the iterator to the given arc of the given digraph. 319 /// 323 /// This constructor sets the iterator to the first arc. 324 325 /// This constructor sets the iterator to the first arc of \c g. 326 ///@param g the digraph 327 ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); } 328 /// Arc -> ArcIt conversion 329 330 /// Sets the iterator to the value of the trivial iterator \c e. 331 /// This feature necessitates that each time we 332 /// iterate the arc-set, the iteration order is the same. 320 333 ArcIt(const Digraph&, const Arc&) { } 321 /// 334 ///Next arc 322 335 323 336 /// Assign the iterator to the next arc. 324 ///325 337 ArcIt& operator++() { return *this; } 326 338 }; 327 328 /// \brief The source node of the arc. 329 /// 330 /// Returns the source node of the given arc. 339 ///Gives back the target node of an arc. 340 341 ///Gives back the target node of an arc. 342 /// 343 Node target(Arc) const { return INVALID; } 344 ///Gives back the source node of an arc. 345 346 ///Gives back the source node of an arc. 347 /// 331 348 Node source(Arc) const { return INVALID; } 332 349 333 /// \brief The target node of the arc. 334 /// 335 /// Returns the target node of the given arc. 336 Node target(Arc) const { return INVALID; } 337 338 /// \brief The ID of the node. 339 /// 340 /// Returns the ID of the given node. 350 /// \brief Returns the ID of the node. 341 351 int id(Node) const { return -1; } 342 352 343 /// \brief The ID of the arc. 344 /// 345 /// Returns the ID of the given arc. 353 /// \brief Returns the ID of the arc. 346 354 int id(Arc) const { return -1; } 347 355 348 /// \brief The node with the given ID. 349 /// 350 /// Returns the node with the given ID. 351 /// \pre The argument should be a valid node ID in the digraph. 356 /// \brief Returns the node with the given ID. 357 /// 358 /// \pre The argument should be a valid node ID in the graph. 352 359 Node nodeFromId(int) const { return INVALID; } 353 360 354 /// \brief The arc with the given ID. 355 /// 356 /// Returns the arc with the given ID. 357 /// \pre The argument should be a valid arc ID in the digraph. 361 /// \brief Returns the arc with the given ID. 362 /// 363 /// \pre The argument should be a valid arc ID in the graph. 358 364 Arc arcFromId(int) const { return INVALID; } 359 365 360 /// \brief An upper bound on the node IDs. 361 /// 362 /// Returns an upper bound on the node IDs. 366 /// \brief Returns an upper bound on the node IDs. 363 367 int maxNodeId() const { return -1; } 364 368 365 /// \brief An upper bound on the arc IDs. 366 /// 367 /// Returns an upper bound on the arc IDs. 369 /// \brief Returns an upper bound on the arc IDs. 368 370 int maxArcId() const { return -1; } 369 371 … … 391 393 int maxId(Arc) const { return -1; } 392 394 393 /// \brief The opposite node on the arc.394 ///395 /// Returns the opposite node on the given arc.396 Node oppositeNode(Node, Arc) const { return INVALID; }397 398 395 /// \brief The base node of the iterator. 399 396 /// 400 /// Returns the base node of the given outgoing arc iterator401 /// (i.e. the source node of the corresponding arc).402 Node baseNode( OutArcIt) const { return INVALID; }397 /// Gives back the base node of the iterator. 398 /// It is always the target of the pointed arc. 399 Node baseNode(const InArcIt&) const { return INVALID; } 403 400 404 401 /// \brief The running node of the iterator. 405 402 /// 406 /// Returns the running node of the given outgoing arc iterator407 /// (i.e. the target node of the corresponding arc).408 Node runningNode( OutArcIt) const { return INVALID; }403 /// Gives back the running node of the iterator. 404 /// It is always the source of the pointed arc. 405 Node runningNode(const InArcIt&) const { return INVALID; } 409 406 410 407 /// \brief The base node of the iterator. 411 408 /// 412 /// Returns the base node of the given incomming arc iterator413 /// (i.e. the target node of the corresponding arc).414 Node baseNode( InArcIt) const { return INVALID; }409 /// Gives back the base node of the iterator. 410 /// It is always the source of the pointed arc. 411 Node baseNode(const OutArcIt&) const { return INVALID; } 415 412 416 413 /// \brief The running node of the iterator. 417 414 /// 418 /// Returns the running node of the given incomming arc iterator 419 /// (i.e. the source node of the corresponding arc). 420 Node runningNode(InArcIt) const { return INVALID; } 421 422 /// \brief Standard graph map type for the nodes. 423 /// 424 /// Standard graph map type for the nodes. 425 /// It conforms to the ReferenceMap concept. 415 /// Gives back the running node of the iterator. 416 /// It is always the target of the pointed arc. 417 Node runningNode(const OutArcIt&) const { return INVALID; } 418 419 /// \brief The opposite node on the given arc. 420 /// 421 /// Gives back the opposite node on the given arc. 422 Node oppositeNode(const Node&, const Arc&) const { return INVALID; } 423 424 /// \brief Reference map of the nodes to type \c T. 425 /// 426 /// Reference map of the nodes to type \c T. 426 427 template<class T> 427 428 class NodeMap : public ReferenceMap<Node, T, T&, const T&> { 428 429 public: 429 430 430 /// Constructor431 explicitNodeMap(const Digraph&) { }432 /// Constructor with given initial value431 ///\e 432 NodeMap(const Digraph&) { } 433 ///\e 433 434 NodeMap(const Digraph&, T) { } 434 435 … … 445 446 }; 446 447 447 /// \brief Standard graph map type for the arcs. 448 /// 449 /// Standard graph map type for the arcs. 450 /// It conforms to the ReferenceMap concept. 448 /// \brief Reference map of the arcs to type \c T. 449 /// 450 /// Reference map of the arcs to type \c T. 451 451 template<class T> 452 452 class ArcMap : public ReferenceMap<Arc, T, T&, const T&> { 453 453 public: 454 454 455 /// Constructor456 explicitArcMap(const Digraph&) { }457 /// Constructor with given initial value455 ///\e 456 ArcMap(const Digraph&) { } 457 ///\e 458 458 ArcMap(const Digraph&, T) { } 459 460 459 private: 461 460 ///Copy constructor -
lemon/concepts/graph.h
r781 r704 19 19 ///\ingroup graph_concepts 20 20 ///\file 21 ///\brief The concept of undirected graphs.21 ///\brief The concept of Undirected Graphs. 22 22 23 23 #ifndef LEMON_CONCEPTS_GRAPH_H … … 25 25 26 26 #include <lemon/concepts/graph_components.h> 27 #include <lemon/concepts/maps.h>28 #include <lemon/concept_check.h>29 27 #include <lemon/core.h> 30 28 … … 34 32 /// \ingroup graph_concepts 35 33 /// 36 /// \brief Class describing the concept of undirected graphs.34 /// \brief Class describing the concept of Undirected Graphs. 37 35 /// 38 /// This class describes the common interface of all undirected39 /// graphs.36 /// This class describes the common interface of all Undirected 37 /// Graphs. 40 38 /// 41 /// Like all concept classes, it only provides aninterface42 /// without any sensible implementation. So any generalalgorithm for43 /// undirected graph sshould compile with this class, but it will not39 /// As all concept describing classes it provides only interface 40 /// without any sensible implementation. So any algorithm for 41 /// undirected graph should compile with this class, but it will not 44 42 /// run properly, of course. 45 /// An actual graph implementation like \ref ListGraph or46 /// \ref SmartGraph may have additional functionality.47 43 /// 48 /// The undirected graphs also fulfill the concept of \ref Digraph 49 /// "directed graphs", since each edge can also be regarded as two 50 /// oppositely directed arcs. 51 /// Undirected graphs provide an Edge type for the undirected edges and 52 /// an Arc type for the directed arcs. The Arc type is convertible to 53 /// Edge or inherited from it, i.e. the corresponding edge can be 54 /// obtained from an arc. 55 /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt 56 /// and ArcMap classes can be used for the arcs (just like in digraphs). 57 /// Both InArcIt and OutArcIt iterates on the same edges but with 58 /// opposite direction. IncEdgeIt also iterates on the same edges 59 /// as OutArcIt and InArcIt, but it is not convertible to Arc, 60 /// only to Edge. 44 /// The LEMON undirected graphs also fulfill the concept of 45 /// directed graphs (\ref lemon::concepts::Digraph "Digraph 46 /// Concept"). Each edges can be seen as two opposite 47 /// directed arc and consequently the undirected graph can be 48 /// seen as the direceted graph of these directed arcs. The 49 /// Graph has the Edge inner class for the edges and 50 /// the Arc type for the directed arcs. The Arc type is 51 /// convertible to Edge or inherited from it so from a directed 52 /// arc we can get the represented edge. 61 53 /// 62 /// In LEMON, each undirected edge has an inherent orientation. 63 /// Thus it can defined if an arc is forward or backward oriented in 64 /// an undirected graph with respect to this default oriantation of 65 /// the represented edge. 66 /// With the direction() and direct() functions the direction 67 /// of an arc can be obtained and set, respectively. 54 /// In the sense of the LEMON each edge has a default 55 /// direction (it should be in every computer implementation, 56 /// because the order of edge's nodes defines an 57 /// orientation). With the default orientation we can define that 58 /// the directed arc is forward or backward directed. With the \c 59 /// direction() and \c direct() function we can get the direction 60 /// of the directed arc and we can direct an edge. 68 61 /// 69 /// Only nodes and edges can be added to or removed from an undirected 70 /// graph and the corresponding arcs are added or removed automatically. 71 /// 72 /// \sa Digraph 62 /// The EdgeIt is an iterator for the edges. We can use 63 /// the EdgeMap to map values for the edges. The InArcIt and 64 /// OutArcIt iterates on the same edges but with opposite 65 /// direction. The IncEdgeIt iterates also on the same edges 66 /// as the OutArcIt and InArcIt but it is not convertible to Arc just 67 /// to Edge. 73 68 class Graph { 74 private:75 /// Graphs are \e not copy constructible. Use DigraphCopy instead.76 Graph(const Graph&) {}77 /// \brief Assignment of a graph to another one is \e not allowed.78 /// Use DigraphCopy instead.79 void operator=(const Graph&) {}80 81 69 public: 82 /// Default constructor. 83 Graph() {} 84 85 /// \brief Undirected graphs should be tagged with \c UndirectedTag. 86 /// 87 /// Undirected graphs should be tagged with \c UndirectedTag. 88 /// 89 /// This tag helps the \c enable_if technics to make compile time 70 /// \brief The undirected graph should be tagged by the 71 /// UndirectedTag. 72 /// 73 /// The undirected graph should be tagged by the UndirectedTag. This 74 /// tag helps the enable_if technics to make compile time 90 75 /// specializations for undirected graphs. 91 76 typedef True UndirectedTag; 92 77 93 /// The node type of the graph 94 95 /// This class identifies a node of the graph. It also serves 96 /// as a base class of the node iterators, 97 /// thus they convert to this type. 78 /// \brief The base type of node iterators, 79 /// or in other words, the trivial node iterator. 80 /// 81 /// This is the base type of each node iterator, 82 /// thus each kind of node iterator converts to this. 83 /// More precisely each kind of node iterator should be inherited 84 /// from the trivial node iterator. 98 85 class Node { 99 86 public: 100 87 /// Default constructor 101 88 102 /// Default constructor.103 /// \warning It sets the objectto an undefined value.89 /// @warning The default constructor sets the iterator 90 /// to an undefined value. 104 91 Node() { } 105 92 /// Copy constructor. … … 109 96 Node(const Node&) { } 110 97 111 /// %Invalid constructor \& conversion.112 113 /// Initializes the objectto be invalid.98 /// Invalid constructor \& conversion. 99 100 /// This constructor initializes the iterator to be invalid. 114 101 /// \sa Invalid for more details. 115 102 Node(Invalid) { } 116 103 /// Equality operator 117 104 118 /// Equality operator.119 ///120 105 /// Two iterators are equal if and only if they point to the 121 /// same object or both are \c INVALID.106 /// same object or both are invalid. 122 107 bool operator==(Node) const { return true; } 123 108 124 109 /// Inequality operator 125 110 126 /// Inequality operator. 111 /// \sa operator==(Node n) 112 /// 127 113 bool operator!=(Node) const { return true; } 128 114 129 115 /// Artificial ordering operator. 130 116 131 /// Artificial ordering operator. 132 /// 133 /// \note This operator only has to define some strict ordering of 117 /// To allow the use of graph descriptors as key type in std::map or 118 /// similar associative container we require this. 119 /// 120 /// \note This operator only have to define some strict ordering of 134 121 /// the items; this order has nothing to do with the iteration 135 122 /// ordering of the items. … … 138 125 }; 139 126 140 /// Iterator class for the nodes.141 142 /// This iterator goes through each node of the graph.127 /// This iterator goes through each node. 128 129 /// This iterator goes through each node. 143 130 /// Its usage is quite simple, for example you can count the number 144 /// of nodes in a graph \c g of type \c %Graph like this:131 /// of nodes in graph \c g of type \c Graph like this: 145 132 ///\code 146 133 /// int count=0; … … 151 138 /// Default constructor 152 139 153 /// Default constructor.154 /// \warning It sets the iteratorto an undefined value.140 /// @warning The default constructor sets the iterator 141 /// to an undefined value. 155 142 NodeIt() { } 156 143 /// Copy constructor. … … 159 146 /// 160 147 NodeIt(const NodeIt& n) : Node(n) { } 161 /// %Invalid constructor \& conversion.162 163 /// Initialize sthe iterator to be invalid.148 /// Invalid constructor \& conversion. 149 150 /// Initialize the iterator to be invalid. 164 151 /// \sa Invalid for more details. 165 152 NodeIt(Invalid) { } 166 153 /// Sets the iterator to the first node. 167 154 168 /// Sets the iterator to the first node of the given digraph. 169 /// 170 explicit NodeIt(const Graph&) { } 171 /// Sets the iterator to the given node. 172 173 /// Sets the iterator to the given node of the given digraph. 174 /// 155 /// Sets the iterator to the first node of \c g. 156 /// 157 NodeIt(const Graph&) { } 158 /// Node -> NodeIt conversion. 159 160 /// Sets the iterator to the node of \c the graph pointed by 161 /// the trivial iterator. 162 /// This feature necessitates that each time we 163 /// iterate the arc-set, the iteration order is the same. 175 164 NodeIt(const Graph&, const Node&) { } 176 165 /// Next node. … … 182 171 183 172 184 /// The edge type of the graph 185 186 /// This class identifies an edge of the graph. It also serves 187 /// as a base class of the edge iterators, 188 /// thus they will convert to this type. 173 /// The base type of the edge iterators. 174 175 /// The base type of the edge iterators. 176 /// 189 177 class Edge { 190 178 public: 191 179 /// Default constructor 192 180 193 /// Default constructor.194 /// \warning It sets the objectto an undefined value.181 /// @warning The default constructor sets the iterator 182 /// to an undefined value. 195 183 Edge() { } 196 184 /// Copy constructor. … … 199 187 /// 200 188 Edge(const Edge&) { } 201 /// %Invalid constructor \& conversion.202 203 /// Initialize s the objectto be invalid.204 /// \sa Invalid for more details.189 /// Initialize the iterator to be invalid. 190 191 /// Initialize the iterator to be invalid. 192 /// 205 193 Edge(Invalid) { } 206 194 /// Equality operator 207 195 208 /// Equality operator.209 ///210 196 /// Two iterators are equal if and only if they point to the 211 /// same object or both are \c INVALID.197 /// same object or both are invalid. 212 198 bool operator==(Edge) const { return true; } 213 199 /// Inequality operator 214 200 215 /// Inequality operator. 201 /// \sa operator==(Edge n) 202 /// 216 203 bool operator!=(Edge) const { return true; } 217 204 218 205 /// Artificial ordering operator. 219 206 220 /// Artificial ordering operator. 221 /// 222 /// \note This operator only has to define some strict ordering of 223 /// the edges; this order has nothing to do with the iteration 224 /// ordering of the edges. 207 /// To allow the use of graph descriptors as key type in std::map or 208 /// similar associative container we require this. 209 /// 210 /// \note This operator only have to define some strict ordering of 211 /// the items; this order has nothing to do with the iteration 212 /// ordering of the items. 225 213 bool operator<(Edge) const { return false; } 226 214 }; 227 215 228 /// Iterator class for the edges.229 230 /// This iterator goes through each edge of thegraph.216 /// This iterator goes through each edge. 217 218 /// This iterator goes through each edge of a graph. 231 219 /// Its usage is quite simple, for example you can count the number 232 /// of edges in a graph \c g of type \c %Graph as follows:220 /// of edges in a graph \c g of type \c Graph as follows: 233 221 ///\code 234 222 /// int count=0; … … 239 227 /// Default constructor 240 228 241 /// Default constructor.242 /// \warning It sets the iteratorto an undefined value.229 /// @warning The default constructor sets the iterator 230 /// to an undefined value. 243 231 EdgeIt() { } 244 232 /// Copy constructor. … … 247 235 /// 248 236 EdgeIt(const EdgeIt& e) : Edge(e) { } 249 /// %Invalid constructor \& conversion.250 251 /// Initialize sthe iterator to be invalid.252 /// \sa Invalid for more details.237 /// Initialize the iterator to be invalid. 238 239 /// Initialize the iterator to be invalid. 240 /// 253 241 EdgeIt(Invalid) { } 254 /// Sets the iterator to the first edge. 255 256 /// Sets the iterator to the first edge of the given graph. 257 /// 258 explicit EdgeIt(const Graph&) { } 259 /// Sets the iterator to the given edge. 260 261 /// Sets the iterator to the given edge of the given graph. 262 /// 242 /// This constructor sets the iterator to the first edge. 243 244 /// This constructor sets the iterator to the first edge. 245 EdgeIt(const Graph&) { } 246 /// Edge -> EdgeIt conversion 247 248 /// Sets the iterator to the value of the trivial iterator. 249 /// This feature necessitates that each time we 250 /// iterate the edge-set, the iteration order is the 251 /// same. 263 252 EdgeIt(const Graph&, const Edge&) { } 264 253 /// Next edge 265 254 266 255 /// Assign the iterator to the next edge. 267 ///268 256 EdgeIt& operator++() { return *this; } 269 257 }; 270 258 271 /// Iterator class for the incident edges of a node. 272 273 /// This iterator goes trough the incident undirected edges 274 /// of a certain node of a graph. 259 /// \brief This iterator goes trough the incident undirected 260 /// arcs of a node. 261 /// 262 /// This iterator goes trough the incident edges 263 /// of a certain node of a graph. You should assume that the 264 /// loop arcs will be iterated twice. 265 /// 275 266 /// Its usage is quite simple, for example you can compute the 276 /// degree (i.e. the number of incident edges)of a node \c n277 /// in a graph \c g of type \c %Graph as follows.267 /// degree (i.e. count the number of incident arcs of a node \c n 268 /// in graph \c g of type \c Graph as follows. 278 269 /// 279 270 ///\code … … 281 272 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; 282 273 ///\endcode 283 ///284 /// \warning Loop edges will be iterated twice.285 274 class IncEdgeIt : public Edge { 286 275 public: 287 276 /// Default constructor 288 277 289 /// Default constructor.290 /// \warning It sets the iteratorto an undefined value.278 /// @warning The default constructor sets the iterator 279 /// to an undefined value. 291 280 IncEdgeIt() { } 292 281 /// Copy constructor. … … 295 284 /// 296 285 IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } 297 /// %Invalid constructor \& conversion.298 299 /// Initialize sthe iterator to be invalid.300 /// \sa Invalid for more details.286 /// Initialize the iterator to be invalid. 287 288 /// Initialize the iterator to be invalid. 289 /// 301 290 IncEdgeIt(Invalid) { } 302 /// Sets the iterator to the first incident edge.303 304 /// Sets the iterator to the first incident edge of the given node.305 /// 291 /// This constructor sets the iterator to first incident arc. 292 293 /// This constructor set the iterator to the first incident arc of 294 /// the node. 306 295 IncEdgeIt(const Graph&, const Node&) { } 307 /// Sets the iterator to the given edge. 308 309 /// Sets the iterator to the given edge of the given graph. 310 /// 296 /// Edge -> IncEdgeIt conversion 297 298 /// Sets the iterator to the value of the trivial iterator \c e. 299 /// This feature necessitates that each time we 300 /// iterate the arc-set, the iteration order is the same. 311 301 IncEdgeIt(const Graph&, const Edge&) { } 312 /// Next incident edge313 314 /// Assign the iterator to the next incident edge302 /// Next incident arc 303 304 /// Assign the iterator to the next incident arc 315 305 /// of the corresponding node. 316 306 IncEdgeIt& operator++() { return *this; } 317 307 }; 318 308 319 /// The arc type of the graph320 321 /// Th is class identifies a directed arc of the graph. It also serves322 /// as a base class of the arc iterators,323 /// thus they will convert to this type.309 /// The directed arc type. 310 311 /// The directed arc type. It can be converted to the 312 /// edge or it should be inherited from the undirected 313 /// edge. 324 314 class Arc { 325 315 public: 326 316 /// Default constructor 327 317 328 /// Default constructor.329 /// \warning It sets the objectto an undefined value.318 /// @warning The default constructor sets the iterator 319 /// to an undefined value. 330 320 Arc() { } 331 321 /// Copy constructor. … … 334 324 /// 335 325 Arc(const Arc&) { } 336 /// %Invalid constructor \& conversion.337 338 /// Initialize s the objectto be invalid.339 /// \sa Invalid for more details.326 /// Initialize the iterator to be invalid. 327 328 /// Initialize the iterator to be invalid. 329 /// 340 330 Arc(Invalid) { } 341 331 /// Equality operator 342 332 343 /// Equality operator.344 ///345 333 /// Two iterators are equal if and only if they point to the 346 /// same object or both are \c INVALID.334 /// same object or both are invalid. 347 335 bool operator==(Arc) const { return true; } 348 336 /// Inequality operator 349 337 350 /// Inequality operator. 338 /// \sa operator==(Arc n) 339 /// 351 340 bool operator!=(Arc) const { return true; } 352 341 353 342 /// Artificial ordering operator. 354 343 355 /// Artificial ordering operator. 356 /// 357 /// \note This operator only has to define some strict ordering of 358 /// the arcs; this order has nothing to do with the iteration 359 /// ordering of the arcs. 344 /// To allow the use of graph descriptors as key type in std::map or 345 /// similar associative container we require this. 346 /// 347 /// \note This operator only have to define some strict ordering of 348 /// the items; this order has nothing to do with the iteration 349 /// ordering of the items. 360 350 bool operator<(Arc) const { return false; } 361 351 362 /// Converison to \c Edge 363 364 /// Converison to \c Edge. 365 /// 352 /// Converison to Edge 366 353 operator Edge() const { return Edge(); } 367 354 }; 368 369 /// Iterator class for the arcs. 370 371 /// This iterator goes through each directed arc of the graph. 355 /// This iterator goes through each directed arc. 356 357 /// This iterator goes through each arc of a graph. 372 358 /// Its usage is quite simple, for example you can count the number 373 /// of arcs in a graph \c g of type \c %Graph as follows:359 /// of arcs in a graph \c g of type \c Graph as follows: 374 360 ///\code 375 361 /// int count=0; 376 /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;362 /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count; 377 363 ///\endcode 378 364 class ArcIt : public Arc { … … 380 366 /// Default constructor 381 367 382 /// Default constructor.383 /// \warning It sets the iteratorto an undefined value.368 /// @warning The default constructor sets the iterator 369 /// to an undefined value. 384 370 ArcIt() { } 385 371 /// Copy constructor. … … 388 374 /// 389 375 ArcIt(const ArcIt& e) : Arc(e) { } 390 /// %Invalid constructor \& conversion.391 392 /// Initialize sthe iterator to be invalid.393 /// \sa Invalid for more details.376 /// Initialize the iterator to be invalid. 377 378 /// Initialize the iterator to be invalid. 379 /// 394 380 ArcIt(Invalid) { } 395 /// Sets the iterator to the first arc. 396 397 /// Sets the iterator to the first arc of the given graph. 398 /// 399 explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } 400 /// Sets the iterator to the given arc. 401 402 /// Sets the iterator to the given arc of the given graph. 403 /// 381 /// This constructor sets the iterator to the first arc. 382 383 /// This constructor sets the iterator to the first arc of \c g. 384 ///@param g the graph 385 ArcIt(const Graph &g) { ignore_unused_variable_warning(g); } 386 /// Arc -> ArcIt conversion 387 388 /// Sets the iterator to the value of the trivial iterator \c e. 389 /// This feature necessitates that each time we 390 /// iterate the arc-set, the iteration order is the same. 404 391 ArcIt(const Graph&, const Arc&) { } 405 /// 392 ///Next arc 406 393 407 394 /// Assign the iterator to the next arc. 408 ///409 395 ArcIt& operator++() { return *this; } 410 396 }; 411 397 412 /// Iterator class for the outgoingarcs of a node.413 414 /// This iterator goes trough the \e outgoing directed arcs of a415 /// certain nodeof a graph.398 /// This iterator goes trough the outgoing directed arcs of a node. 399 400 /// This iterator goes trough the \e outgoing arcs of a certain node 401 /// of a graph. 416 402 /// Its usage is quite simple, for example you can count the number 417 403 /// of outgoing arcs of a node \c n 418 /// in a graph \c g of type \c %Graph as follows.404 /// in graph \c g of type \c Graph as follows. 419 405 ///\code 420 406 /// int count=0; 421 /// for ( Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;407 /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count; 422 408 ///\endcode 409 423 410 class OutArcIt : public Arc { 424 411 public: 425 412 /// Default constructor 426 413 427 /// Default constructor.428 /// \warning It sets the iteratorto an undefined value.414 /// @warning The default constructor sets the iterator 415 /// to an undefined value. 429 416 OutArcIt() { } 430 417 /// Copy constructor. … … 433 420 /// 434 421 OutArcIt(const OutArcIt& e) : Arc(e) { } 435 /// %Invalid constructor \& conversion.436 437 /// Initialize sthe iterator to be invalid.438 /// \sa Invalid for more details.422 /// Initialize the iterator to be invalid. 423 424 /// Initialize the iterator to be invalid. 425 /// 439 426 OutArcIt(Invalid) { } 440 /// Sets the iterator to the first outgoing arc. 441 442 /// Sets the iterator to the first outgoing arc of the given node. 443 /// 427 /// This constructor sets the iterator to the first outgoing arc. 428 429 /// This constructor sets the iterator to the first outgoing arc of 430 /// the node. 431 ///@param n the node 432 ///@param g the graph 444 433 OutArcIt(const Graph& n, const Node& g) { 445 434 ignore_unused_variable_warning(n); 446 435 ignore_unused_variable_warning(g); 447 436 } 448 /// Sets the iterator to the given arc. 449 450 /// Sets the iterator to the given arc of the given graph. 451 /// 437 /// Arc -> OutArcIt conversion 438 439 /// Sets the iterator to the value of the trivial iterator. 440 /// This feature necessitates that each time we 441 /// iterate the arc-set, the iteration order is the same. 452 442 OutArcIt(const Graph&, const Arc&) { } 453 /// 443 ///Next outgoing arc 454 444 455 445 /// Assign the iterator to the next … … 458 448 }; 459 449 460 /// Iterator class for the incomingarcs of a node.461 462 /// This iterator goes trough the \e incoming directed arcs of a463 /// certain nodeof a graph.450 /// This iterator goes trough the incoming directed arcs of a node. 451 452 /// This iterator goes trough the \e incoming arcs of a certain node 453 /// of a graph. 464 454 /// Its usage is quite simple, for example you can count the number 465 /// of incoming arcs of a node \c n466 /// in a graph \c g of type \c %Graph as follows.455 /// of outgoing arcs of a node \c n 456 /// in graph \c g of type \c Graph as follows. 467 457 ///\code 468 458 /// int count=0; 469 /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;459 /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count; 470 460 ///\endcode 461 471 462 class InArcIt : public Arc { 472 463 public: 473 464 /// Default constructor 474 465 475 /// Default constructor.476 /// \warning It sets the iteratorto an undefined value.466 /// @warning The default constructor sets the iterator 467 /// to an undefined value. 477 468 InArcIt() { } 478 469 /// Copy constructor. … … 481 472 /// 482 473 InArcIt(const InArcIt& e) : Arc(e) { } 483 /// %Invalid constructor \& conversion.484 485 /// Initialize sthe iterator to be invalid.486 /// \sa Invalid for more details.474 /// Initialize the iterator to be invalid. 475 476 /// Initialize the iterator to be invalid. 477 /// 487 478 InArcIt(Invalid) { } 488 /// Sets the iterator to the first incoming arc. 489 490 /// Sets the iterator to the first incoming arc of the given node. 491 /// 479 /// This constructor sets the iterator to first incoming arc. 480 481 /// This constructor set the iterator to the first incoming arc of 482 /// the node. 483 ///@param n the node 484 ///@param g the graph 492 485 InArcIt(const Graph& g, const Node& n) { 493 486 ignore_unused_variable_warning(n); 494 487 ignore_unused_variable_warning(g); 495 488 } 496 /// Sets the iterator to the given arc. 497 498 /// Sets the iterator to the given arc of the given graph. 499 /// 489 /// Arc -> InArcIt conversion 490 491 /// Sets the iterator to the value of the trivial iterator \c e. 492 /// This feature necessitates that each time we 493 /// iterate the arc-set, the iteration order is the same. 500 494 InArcIt(const Graph&, const Arc&) { } 501 495 /// Next incoming arc 502 496 503 /// Assign the iterator to the next 504 /// incoming arc of the corresponding node.497 /// Assign the iterator to the next inarc of the corresponding node. 498 /// 505 499 InArcIt& operator++() { return *this; } 506 500 }; 507 501 508 /// \brief Standard graph map type for the nodes. 509 /// 510 /// Standard graph map type for the nodes. 511 /// It conforms to the ReferenceMap concept. 502 /// \brief Reference map of the nodes to type \c T. 503 /// 504 /// Reference map of the nodes to type \c T. 512 505 template<class T> 513 506 class NodeMap : public ReferenceMap<Node, T, T&, const T&> … … 515 508 public: 516 509 517 /// Constructor518 explicitNodeMap(const Graph&) { }519 /// Constructor with given initial value510 ///\e 511 NodeMap(const Graph&) { } 512 ///\e 520 513 NodeMap(const Graph&, T) { } 521 514 … … 532 525 }; 533 526 534 /// \brief Standard graph map type for the arcs. 535 /// 536 /// Standard graph map type for the arcs. 537 /// It conforms to the ReferenceMap concept. 527 /// \brief Reference map of the arcs to type \c T. 528 /// 529 /// Reference map of the arcs to type \c T. 538 530 template<class T> 539 531 class ArcMap : public ReferenceMap<Arc, T, T&, const T&> … … 541 533 public: 542 534 543 /// Constructor544 explicitArcMap(const Graph&) { }545 /// Constructor with given initial value535 ///\e 536 ArcMap(const Graph&) { } 537 ///\e 546 538 ArcMap(const Graph&, T) { } 547 548 539 private: 549 540 ///Copy constructor … … 558 549 }; 559 550 560 /// \brief Standard graph map type for the edges. 561 /// 562 /// Standard graph map type for the edges. 563 /// It conforms to the ReferenceMap concept. 551 /// Reference map of the edges to type \c T. 552 553 /// Reference map of the edges to type \c T. 564 554 template<class T> 565 555 class EdgeMap : public ReferenceMap<Edge, T, T&, const T&> … … 567 557 public: 568 558 569 /// Constructor570 explicitEdgeMap(const Graph&) { }571 /// Constructor with given initial value559 ///\e 560 EdgeMap(const Graph&) { } 561 ///\e 572 562 EdgeMap(const Graph&, T) { } 573 574 563 private: 575 564 ///Copy constructor … … 584 573 }; 585 574 586 /// \brief The first node of the edge. 587 /// 588 /// Returns the first node of the given edge. 589 /// 590 /// Edges don't have source and target nodes, however methods 591 /// u() and v() are used to query the two end-nodes of an edge. 592 /// The orientation of an edge that arises this way is called 593 /// the inherent direction, it is used to define the default 594 /// direction for the corresponding arcs. 575 /// \brief Direct the given edge. 576 /// 577 /// Direct the given edge. The returned arc source 578 /// will be the given node. 579 Arc direct(const Edge&, const Node&) const { 580 return INVALID; 581 } 582 583 /// \brief Direct the given edge. 584 /// 585 /// Direct the given edge. The returned arc 586 /// represents the given edge and the direction comes 587 /// from the bool parameter. The source of the edge and 588 /// the directed arc is the same when the given bool is true. 589 Arc direct(const Edge&, bool) const { 590 return INVALID; 591 } 592 593 /// \brief Returns true if the arc has default orientation. 594 /// 595 /// Returns whether the given directed arc is same orientation as 596 /// the corresponding edge's default orientation. 597 bool direction(Arc) const { return true; } 598 599 /// \brief Returns the opposite directed arc. 600 /// 601 /// Returns the opposite directed arc. 602 Arc oppositeArc(Arc) const { return INVALID; } 603 604 /// \brief Opposite node on an arc 605 /// 606 /// \return The opposite of the given node on the given edge. 607 Node oppositeNode(Node, Edge) const { return INVALID; } 608 609 /// \brief First node of the edge. 610 /// 611 /// \return The first node of the given edge. 612 /// 613 /// Naturally edges don't have direction and thus 614 /// don't have source and target node. However we use \c u() and \c v() 615 /// methods to query the two nodes of the arc. The direction of the 616 /// arc which arises this way is called the inherent direction of the 617 /// edge, and is used to define the "default" direction 618 /// of the directed versions of the arcs. 595 619 /// \sa v() 596 620 /// \sa direction() 597 621 Node u(Edge) const { return INVALID; } 598 622 599 /// \brief The second node of the edge. 600 /// 601 /// Returns the second node of the given edge. 602 /// 603 /// Edges don't have source and target nodes, however methods 604 /// u() and v() are used to query the two end-nodes of an edge. 605 /// The orientation of an edge that arises this way is called 606 /// the inherent direction, it is used to define the default 607 /// direction for the corresponding arcs. 623 /// \brief Second node of the edge. 624 /// 625 /// \return The second node of the given edge. 626 /// 627 /// Naturally edges don't have direction and thus 628 /// don't have source and target node. However we use \c u() and \c v() 629 /// methods to query the two nodes of the arc. The direction of the 630 /// arc which arises this way is called the inherent direction of the 631 /// edge, and is used to define the "default" direction 632 /// of the directed versions of the arcs. 608 633 /// \sa u() 609 634 /// \sa direction() 610 635 Node v(Edge) const { return INVALID; } 611 636 612 /// \brief The source node of the arc. 613 /// 614 /// Returns the source node of the given arc. 637 /// \brief Source node of the directed arc. 615 638 Node source(Arc) const { return INVALID; } 616 639 617 /// \brief The target node of the arc. 618 /// 619 /// Returns the target node of the given arc. 640 /// \brief Target node of the directed arc. 620 641 Node target(Arc) const { return INVALID; } 621 642 622 /// \brief The ID of the node. 623 /// 624 /// Returns the ID of the given node. 643 /// \brief Returns the id of the node. 625 644 int id(Node) const { return -1; } 626 645 627 /// \brief The ID of the edge. 628 /// 629 /// Returns the ID of the given edge. 646 /// \brief Returns the id of the edge. 630 647 int id(Edge) const { return -1; } 631 648 632 /// \brief The ID of the arc. 633 /// 634 /// Returns the ID of the given arc. 649 /// \brief Returns the id of the arc. 635 650 int id(Arc) const { return -1; } 636 651 637 /// \brief The node with the given ID. 638 /// 639 /// Returns the node with the given ID. 640 /// \pre The argument should be a valid node ID in the graph. 652 /// \brief Returns the node with the given id. 653 /// 654 /// \pre The argument should be a valid node id in the graph. 641 655 Node nodeFromId(int) const { return INVALID; } 642 656 643 /// \brief The edge with the given ID. 644 /// 645 /// Returns the edge with the given ID. 646 /// \pre The argument should be a valid edge ID in the graph. 657 /// \brief Returns the edge with the given id. 658 /// 659 /// \pre The argument should be a valid edge id in the graph. 647 660 Edge edgeFromId(int) const { return INVALID; } 648 661 649 /// \brief The arc with the given ID. 650 /// 651 /// Returns the arc with the given ID. 652 /// \pre The argument should be a valid arc ID in the graph. 662 /// \brief Returns the arc with the given id. 663 /// 664 /// \pre The argument should be a valid arc id in the graph. 653 665 Arc arcFromId(int) const { return INVALID; } 654 666 655 /// \brief An upper bound on the node IDs. 656 /// 657 /// Returns an upper bound on the node IDs. 667 /// \brief Returns an upper bound on the node IDs. 658 668 int maxNodeId() const { return -1; } 659 669 660 /// \brief An upper bound on the edge IDs. 661 /// 662 /// Returns an upper bound on the edge IDs. 670 /// \brief Returns an upper bound on the edge IDs. 663 671 int maxEdgeId() const { return -1; } 664 672 665 /// \brief An upper bound on the arc IDs. 666 /// 667 /// Returns an upper bound on the arc IDs. 673 /// \brief Returns an upper bound on the arc IDs. 668 674 int maxArcId() const { return -1; } 669 670 /// \brief The direction of the arc.671 ///672 /// Returns \c true if the direction of the given arc is the same as673 /// the inherent orientation of the represented edge.674 bool direction(Arc) const { return true; }675 676 /// \brief Direct the edge.677 ///678 /// Direct the given edge. The returned arc679 /// represents the given edge and its direction comes680 /// from the bool parameter. If it is \c true, then the direction681 /// of the arc is the same as the inherent orientation of the edge.682 Arc direct(Edge, bool) const {683 return INVALID;684 }685 686 /// \brief Direct the edge.687 ///688 /// Direct the given edge. The returned arc represents the given689 /// edge and its source node is the given node.690 Arc direct(Edge, Node) const {691 return INVALID;692 }693 694 /// \brief The oppositely directed arc.695 ///696 /// Returns the oppositely directed arc representing the same edge.697 Arc oppositeArc(Arc) const { return INVALID; }698 699 /// \brief The opposite node on the edge.700 ///701 /// Returns the opposite node on the given edge.702 Node oppositeNode(Node, Edge) const { return INVALID; }703 675 704 676 void first(Node&) const {} … … 734 706 int maxId(Arc) const { return -1; } 735 707 736 /// \brief The base node of the iterator. 737 /// 738 /// Returns the base node of the given incident edge iterator. 739 Node baseNode(IncEdgeIt) const { return INVALID; } 740 741 /// \brief The running node of the iterator. 742 /// 743 /// Returns the running node of the given incident edge iterator. 744 Node runningNode(IncEdgeIt) const { return INVALID; } 745 746 /// \brief The base node of the iterator. 747 /// 748 /// Returns the base node of the given outgoing arc iterator 749 /// (i.e. the source node of the corresponding arc). 750 Node baseNode(OutArcIt) const { return INVALID; } 751 752 /// \brief The running node of the iterator. 753 /// 754 /// Returns the running node of the given outgoing arc iterator 755 /// (i.e. the target node of the corresponding arc). 756 Node runningNode(OutArcIt) const { return INVALID; } 757 758 /// \brief The base node of the iterator. 759 /// 760 /// Returns the base node of the given incomming arc iterator 761 /// (i.e. the target node of the corresponding arc). 762 Node baseNode(InArcIt) const { return INVALID; } 763 764 /// \brief The running node of the iterator. 765 /// 766 /// Returns the running node of the given incomming arc iterator 767 /// (i.e. the source node of the corresponding arc). 768 Node runningNode(InArcIt) const { return INVALID; } 708 /// \brief Base node of the iterator 709 /// 710 /// Returns the base node (the source in this case) of the iterator 711 Node baseNode(OutArcIt e) const { 712 return source(e); 713 } 714 /// \brief Running node of the iterator 715 /// 716 /// Returns the running node (the target in this case) of the 717 /// iterator 718 Node runningNode(OutArcIt e) const { 719 return target(e); 720 } 721 722 /// \brief Base node of the iterator 723 /// 724 /// Returns the base node (the target in this case) of the iterator 725 Node baseNode(InArcIt e) const { 726 return target(e); 727 } 728 /// \brief Running node of the iterator 729 /// 730 /// Returns the running node (the source in this case) of the 731 /// iterator 732 Node runningNode(InArcIt e) const { 733 return source(e); 734 } 735 736 /// \brief Base node of the iterator 737 /// 738 /// Returns the base node of the iterator 739 Node baseNode(IncEdgeIt) const { 740 return INVALID; 741 } 742 743 /// \brief Running node of the iterator 744 /// 745 /// Returns the running node of the iterator 746 Node runningNode(IncEdgeIt) const { 747 return INVALID; 748 } 769 749 770 750 template <typename _Graph> -
lemon/concepts/graph_components.h
r781 r713 93 93 /// associative containers (e.g. \c std::map). 94 94 /// 95 /// \note This operator only ha sto define some strict ordering of95 /// \note This operator only have to define some strict ordering of 96 96 /// the items; this order has nothing to do with the iteration 97 97 /// ordering of the items. -
lemon/concepts/heap.h
r757 r631 17 17 */ 18 18 19 #ifndef LEMON_CONCEPTS_HEAP_H20 #define LEMON_CONCEPTS_HEAP_H21 22 19 ///\ingroup concept 23 20 ///\file 24 21 ///\brief The concept of heaps. 25 22 23 #ifndef LEMON_CONCEPTS_HEAP_H 24 #define LEMON_CONCEPTS_HEAP_H 25 26 26 #include <lemon/core.h> 27 27 #include <lemon/concept_check.h> … … 36 36 /// \brief The heap concept. 37 37 /// 38 /// This concept class describes the main interface of heaps. 39 /// The various \ref heaps "heap structures" are efficient 40 /// implementations of the abstract data type \e priority \e queue. 41 /// They store items with specified values called \e priorities 42 /// in such a way that finding and removing the item with minimum 43 /// priority are efficient. The basic operations are adding and 44 /// erasing items, changing the priority of an item, etc. 38 /// Concept class describing the main interface of heaps. A \e heap 39 /// is a data structure for storing items with specified values called 40 /// \e priorities in such a way that finding the item with minimum 41 /// priority is efficient. In a heap one can change the priority of an 42 /// item, add or erase an item, etc. 45 43 /// 46 /// Heaps are crucial in several algorithms, such as Dijkstra and Prim. 47 /// Any class that conforms to this concept can be used easily in such 48 /// algorithms. 49 /// 50 /// \tparam PR Type of the priorities of the items. 51 /// \tparam IM A read-writable item map with \c int values, used 44 /// \tparam PR Type of the priority of the items. 45 /// \tparam IM A read and writable item map with int values, used 52 46 /// internally to handle the cross references. 53 /// \tparam C MP A functor class for comparingthe priorities.47 /// \tparam Comp A functor class for the ordering of the priorities. 54 48 /// The default is \c std::less<PR>. 55 49 #ifdef DOXYGEN 56 template <typename PR, typename IM, typename C MP>50 template <typename PR, typename IM, typename Comp = std::less<PR> > 57 51 #else 58 template <typename PR, typename IM , typename CMP = std::less<PR>>52 template <typename PR, typename IM> 59 53 #endif 60 54 class Heap { … … 71 65 /// 72 66 /// Each item has a state associated to it. It can be "in heap", 73 /// "pre-heap" or "post-heap". The latter two are indifferent from the 74 /// heap's point of view, but may be useful to the user. 67 /// "pre heap" or "post heap". The later two are indifferent 68 /// from the point of view of the heap, but may be useful for 69 /// the user. 75 70 /// 76 71 /// The item-int map must be initialized in such way that it assigns … … 78 73 enum State { 79 74 IN_HEAP = 0, ///< = 0. The "in heap" state constant. 80 PRE_HEAP = -1, ///< = -1. The "pre -heap" state constant.81 POST_HEAP = -2 ///< = -2. The "post -heap" state constant.75 PRE_HEAP = -1, ///< = -1. The "pre heap" state constant. 76 POST_HEAP = -2 ///< = -2. The "post heap" state constant. 82 77 }; 83 78 84 /// \brief Constructor.85 /// 86 /// Constructor.79 /// \brief The constructor. 80 /// 81 /// The constructor. 87 82 /// \param map A map that assigns \c int values to keys of type 88 83 /// \c Item. It is used internally by the heap implementations to 89 84 /// handle the cross references. The assigned value must be 90 /// \c PRE_HEAP (<tt>-1</tt>) for e achitem.85 /// \c PRE_HEAP (<tt>-1</tt>) for every item. 91 86 explicit Heap(ItemIntMap &map) {} 92 87 93 /// \brief Constructor.94 ///95 /// Constructor.96 /// \param map A map that assigns \c int values to keys of type97 /// \c Item. It is used internally by the heap implementations to98 /// handle the cross references. The assigned value must be99 /// \c PRE_HEAP (<tt>-1</tt>) for each item.100 /// \param comp The function object used for comparing the priorities.101 explicit Heap(ItemIntMap &map, const CMP &comp) {}102 103 88 /// \brief The number of items stored in the heap. 104 89 /// 105 /// This function returns the number of items stored in the heap.90 /// Returns the number of items stored in the heap. 106 91 int size() const { return 0; } 107 92 108 /// \brief Check if the heap is empty.109 /// 110 /// This function returns \c true if the heap is empty.93 /// \brief Checks if the heap is empty. 94 /// 95 /// Returns \c true if the heap is empty. 111 96 bool empty() const { return false; } 112 97 113 /// \brief Make the heap empty. 114 /// 115 /// This functon makes the heap empty. 116 /// It does not change the cross reference map. If you want to reuse 117 /// a heap that is not surely empty, you should first clear it and 118 /// then you should set the cross reference map to \c PRE_HEAP 119 /// for each item. 120 void clear() {} 121 122 /// \brief Insert an item into the heap with the given priority. 123 /// 124 /// This function inserts the given item into the heap with the 125 /// given priority. 98 /// \brief Makes the heap empty. 99 /// 100 /// Makes the heap empty. 101 void clear(); 102 103 /// \brief Inserts an item into the heap with the given priority. 104 /// 105 /// Inserts the given item into the heap with the given priority. 126 106 /// \param i The item to insert. 127 107 /// \param p The priority of the item. 128 /// \pre \e i must not be stored in the heap.129 108 void push(const Item &i, const Prio &p) {} 130 109 131 /// \brief Return the item having minimum priority.132 /// 133 /// This function returns the item having minimum priority.110 /// \brief Returns the item having minimum priority. 111 /// 112 /// Returns the item having minimum priority. 134 113 /// \pre The heap must be non-empty. 135 114 Item top() const {} … … 137 116 /// \brief The minimum priority. 138 117 /// 139 /// This function returns the minimum priority.118 /// Returns the minimum priority. 140 119 /// \pre The heap must be non-empty. 141 120 Prio prio() const {} 142 121 143 /// \brief Remove the item having minimum priority.144 /// 145 /// This function removes the item having minimum priority.122 /// \brief Removes the item having minimum priority. 123 /// 124 /// Removes the item having minimum priority. 146 125 /// \pre The heap must be non-empty. 147 126 void pop() {} 148 127 149 /// \brief Remove the given item from the heap. 150 /// 151 /// This function removes the given item from the heap if it is 152 /// already stored. 128 /// \brief Removes an item from the heap. 129 /// 130 /// Removes the given item from the heap if it is already stored. 153 131 /// \param i The item to delete. 154 /// \pre \e i must be in the heap.155 132 void erase(const Item &i) {} 156 133 157 /// \brief The priority of the given item.158 /// 159 /// This function returns the priority of the given item.160 /// \param i The item. 161 /// \pre \ ei must be in the heap.134 /// \brief The priority of an item. 135 /// 136 /// Returns the priority of the given item. 137 /// \param i The item. 138 /// \pre \c i must be in the heap. 162 139 Prio operator[](const Item &i) const {} 163 140 164 /// \brief Set the priority of an item or insertit, if it is141 /// \brief Sets the priority of an item or inserts it, if it is 165 142 /// not stored in the heap. 166 143 /// 167 144 /// This method sets the priority of the given item if it is 168 /// already stored in the heap. Otherwise it inserts the given169 /// item into the heapwith the given priority.145 /// already stored in the heap. 146 /// Otherwise it inserts the given item with the given priority. 170 147 /// 171 148 /// \param i The item. … … 173 150 void set(const Item &i, const Prio &p) {} 174 151 175 /// \brief Decrease the priority of an item to the given value.176 /// 177 /// This function decreases the priority of an item to the given value.152 /// \brief Decreases the priority of an item to the given value. 153 /// 154 /// Decreases the priority of an item to the given value. 178 155 /// \param i The item. 179 156 /// \param p The priority. 180 /// \pre \ e i must be stored in the heap with priority at least \ep.157 /// \pre \c i must be stored in the heap with priority at least \c p. 181 158 void decrease(const Item &i, const Prio &p) {} 182 159 183 /// \brief Increase the priority of an item to the given value.184 /// 185 /// This function increases the priority of an item to the given value.160 /// \brief Increases the priority of an item to the given value. 161 /// 162 /// Increases the priority of an item to the given value. 186 163 /// \param i The item. 187 164 /// \param p The priority. 188 /// \pre \ e i must be stored in the heap with priority at most \ep.165 /// \pre \c i must be stored in the heap with priority at most \c p. 189 166 void increase(const Item &i, const Prio &p) {} 190 167 191 /// \brief Return the state of an item. 168 /// \brief Returns if an item is in, has already been in, or has 169 /// never been in the heap. 192 170 /// 193 171 /// This method returns \c PRE_HEAP if the given item has never … … 199 177 State state(const Item &i) const {} 200 178 201 /// \brief Set the state of an item in the heap.202 /// 203 /// This function sets the state of the given item in the heap.204 /// It can be used to manually clear the heap when it is important205 /// to achivebetter time complexity.179 /// \brief Sets the state of an item in the heap. 180 /// 181 /// Sets the state of the given item in the heap. It can be used 182 /// to manually clear the heap when it is important to achive the 183 /// better time complexity. 206 184 /// \param i The item. 207 185 /// \param st The state. It should not be \c IN_HEAP. -
lemon/concepts/maps.h
r765 r576 183 183 template<typename _ReferenceMap> 184 184 struct Constraints { 185 typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type 186 constraints() { 185 void constraints() { 187 186 checkConcept<ReadWriteMap<K, T>, _ReferenceMap >(); 188 187 ref = m[key]; -
lemon/cplex.cc
r793 r623 112 112 } 113 113 114 int CplexBase::_addRow(Value lb, ExprIterator b,115 ExprIterator e, Value ub) {116 int i = CPXgetnumrows(cplexEnv(), _prob);117 if (lb == -INF) {118 const char s = 'L';119 CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);120 } else if (ub == INF) {121 const char s = 'G';122 CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);123 } else if (lb == ub){124 const char s = 'E';125 CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);126 } else {127 const char s = 'R';128 double len = ub - lb;129 CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);130 }131 132 std::vector<int> indices;133 std::vector<int> rowlist;134 std::vector<Value> values;135 136 for(ExprIterator it=b; it!=e; ++it) {137 indices.push_back(it->first);138 values.push_back(it->second);139 rowlist.push_back(i);140 }141 142 CPXchgcoeflist(cplexEnv(), _prob, values.size(),143 &rowlist.front(), &indices.front(), &values.front());144 145 return i;146 }147 114 148 115 void CplexBase::_eraseCol(int i) { -
lemon/cplex.h
r793 r623 94 94 virtual int _addCol(); 95 95 virtual int _addRow(); 96 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);97 96 98 97 virtual void _eraseCol(int i); -
lemon/dfs.h
r764 r631 48 48 ///The type of the map that stores the predecessor 49 49 ///arcs of the %DFS paths. 50 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.50 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 51 51 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 52 52 ///Instantiates a \c PredMap. … … 63 63 64 64 ///The type of the map that indicates which nodes are processed. 65 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 66 ///By default it is a NullMap. 65 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 67 66 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; 68 67 ///Instantiates a \c ProcessedMap. … … 83 82 84 83 ///The type of the map that indicates which nodes are reached. 85 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.84 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 86 85 typedef typename Digraph::template NodeMap<bool> ReachedMap; 87 86 ///Instantiates a \c ReachedMap. … … 98 97 99 98 ///The type of the map that stores the distances of the nodes. 100 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.99 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 101 100 typedef typename Digraph::template NodeMap<int> DistMap; 102 101 ///Instantiates a \c DistMap. … … 226 225 ///\ref named-templ-param "Named parameter" for setting 227 226 ///\c PredMap type. 228 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.227 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 229 228 template <class T> 230 229 struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > { … … 246 245 ///\ref named-templ-param "Named parameter" for setting 247 246 ///\c DistMap type. 248 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.247 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 249 248 template <class T> 250 249 struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > { … … 266 265 ///\ref named-templ-param "Named parameter" for setting 267 266 ///\c ReachedMap type. 268 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.267 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 269 268 template <class T> 270 269 struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > { … … 286 285 ///\ref named-templ-param "Named parameter" for setting 287 286 ///\c ProcessedMap type. 288 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.287 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 289 288 template <class T> 290 289 struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > { … … 413 412 ///The simplest way to execute the DFS algorithm is to use one of the 414 413 ///member functions called \ref run(Node) "run()".\n 415 ///If you need better control on the execution,you have to call416 ///\ref init() first, then you can add a source node with \ref addSource()414 ///If you need more control on the execution, first you have to call 415 ///\ref init(), then you can add a source node with \ref addSource() 417 416 ///and perform the actual computation with \ref start(). 418 417 ///This procedure can be repeated if there are nodes that have not … … 671 670 ///@{ 672 671 673 ///The DFS path to the givennode.674 675 ///Returns the DFS path to the given node from the root(s).672 ///The DFS path to a node. 673 674 ///Returns the DFS path to a node. 676 675 /// 677 676 ///\warning \c t should be reached from the root(s). … … 681 680 Path path(Node t) const { return Path(*G, *_pred, t); } 682 681 683 ///The distance of the givennode from the root(s).684 685 ///Returns the distance of the givennode from the root(s).682 ///The distance of a node from the root(s). 683 684 ///Returns the distance of a node from the root(s). 686 685 /// 687 686 ///\warning If node \c v is not reached from the root(s), then … … 692 691 int dist(Node v) const { return (*_dist)[v]; } 693 692 694 ///Returns the 'previous arc' of the %DFS tree for the givennode.693 ///Returns the 'previous arc' of the %DFS tree for a node. 695 694 696 695 ///This function returns the 'previous arc' of the %DFS tree for the … … 700 699 /// 701 700 ///The %DFS tree used here is equal to the %DFS tree used in 702 ///\ref predNode() and \ref predMap().701 ///\ref predNode(). 703 702 /// 704 703 ///\pre Either \ref run(Node) "run()" or \ref init() … … 706 705 Arc predArc(Node v) const { return (*_pred)[v];} 707 706 708 ///Returns the 'previous node' of the %DFS tree for the given node.707 ///Returns the 'previous node' of the %DFS tree. 709 708 710 709 ///This function returns the 'previous node' of the %DFS 711 710 ///tree for the node \c v, i.e. it returns the last but one node 712 /// ofa %DFS path from a root to \c v. It is \c INVALID711 ///from a %DFS path from a root to \c v. It is \c INVALID 713 712 ///if \c v is not reached from the root(s) or if \c v is a root. 714 713 /// 715 714 ///The %DFS tree used here is equal to the %DFS tree used in 716 ///\ref predArc() and \ref predMap().715 ///\ref predArc(). 717 716 /// 718 717 ///\pre Either \ref run(Node) "run()" or \ref init() … … 735 734 /// 736 735 ///Returns a const reference to the node map that stores the predecessor 737 ///arcs, which form the DFS tree (forest).736 ///arcs, which form the DFS tree. 738 737 /// 739 738 ///\pre Either \ref run(Node) "run()" or \ref init() … … 741 740 const PredMap &predMap() const { return *_pred;} 742 741 743 ///Checks if the given node.node is reached from the root(s).742 ///Checks if a node is reached from the root(s). 744 743 745 744 ///Returns \c true if \c v is reached from the root(s). … … 767 766 ///The type of the map that stores the predecessor 768 767 ///arcs of the %DFS paths. 769 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.768 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 770 769 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 771 770 ///Instantiates a PredMap. … … 782 781 783 782 ///The type of the map that indicates which nodes are processed. 784 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.783 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 785 784 ///By default it is a NullMap. 786 785 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 802 801 803 802 ///The type of the map that indicates which nodes are reached. 804 ///It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.803 ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 805 804 typedef typename Digraph::template NodeMap<bool> ReachedMap; 806 805 ///Instantiates a ReachedMap. … … 817 816 818 817 ///The type of the map that stores the distances of the nodes. 819 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.818 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 820 819 typedef typename Digraph::template NodeMap<int> DistMap; 821 820 ///Instantiates a DistMap. … … 832 831 833 832 ///The type of the DFS paths. 834 ///It must conform tothe \ref concepts::Path "Path" concept.833 ///It must meet the \ref concepts::Path "Path" concept. 835 834 typedef lemon::Path<Digraph> Path; 836 835 }; … … 838 837 /// Default traits class used by DfsWizard 839 838 840 /// Default traits class used by DfsWizard. 841 /// \tparam GR The type of the digraph. 839 /// To make it easier to use Dfs algorithm 840 /// we have created a wizard class. 841 /// This \ref DfsWizard class needs default traits, 842 /// as well as the \ref Dfs class. 843 /// The \ref DfsWizardBase is a class to be the default traits of the 844 /// \ref DfsWizard class. 842 845 template<class GR> 843 846 class DfsWizardBase : public DfsWizardDefaultTraits<GR> … … 867 870 /// Constructor. 868 871 869 /// This constructor does not require parameters, it initiates872 /// This constructor does not require parameters, therefore it initiates 870 873 /// all of the attributes to \c 0. 871 874 DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), … … 897 900 typedef TR Base; 898 901 902 ///The type of the digraph the algorithm runs on. 899 903 typedef typename TR::Digraph Digraph; 900 904 … … 904 908 typedef typename Digraph::OutArcIt OutArcIt; 905 909 910 ///\brief The type of the map that stores the predecessor 911 ///arcs of the DFS paths. 906 912 typedef typename TR::PredMap PredMap; 913 ///\brief The type of the map that stores the distances of the nodes. 907 914 typedef typename TR::DistMap DistMap; 915 ///\brief The type of the map that indicates which nodes are reached. 908 916 typedef typename TR::ReachedMap ReachedMap; 917 ///\brief The type of the map that indicates which nodes are processed. 909 918 typedef typename TR::ProcessedMap ProcessedMap; 919 ///The type of the DFS paths 910 920 typedef typename TR::Path Path; 911 921 … … 990 1000 SetPredMapBase(const TR &b) : TR(b) {} 991 1001 }; 992 993 ///\brief \ref named-templ-param "Named parameter" for setting 994 ///the predecessor map. 995 /// 996 ///\ref named-templ-param "Named parameter" function for setting 997 ///the map that stores the predecessor arcs of the nodes. 1002 ///\brief \ref named-func-param "Named parameter" 1003 ///for setting PredMap object. 1004 /// 1005 ///\ref named-func-param "Named parameter" 1006 ///for setting PredMap object. 998 1007 template<class T> 999 1008 DfsWizard<SetPredMapBase<T> > predMap(const T &t) … … 1009 1018 SetReachedMapBase(const TR &b) : TR(b) {} 1010 1019 }; 1011 1012 ///\brief \ref named-templ-param "Named parameter" for setting 1013 ///the reached map. 1014 /// 1015 ///\ref named-templ-param "Named parameter" function for setting 1016 ///the map that indicates which nodes are reached. 1020 ///\brief \ref named-func-param "Named parameter" 1021 ///for setting ReachedMap object. 1022 /// 1023 /// \ref named-func-param "Named parameter" 1024 ///for setting ReachedMap object. 1017 1025 template<class T> 1018 1026 DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) … … 1028 1036 SetDistMapBase(const TR &b) : TR(b) {} 1029 1037 }; 1030 1031 ///\brief \ref named-templ-param "Named parameter" for setting 1032 ///the distance map. 1033 /// 1034 ///\ref named-templ-param "Named parameter" function for setting 1035 ///the map that stores the distances of the nodes calculated 1036 ///by the algorithm. 1038 ///\brief \ref named-func-param "Named parameter" 1039 ///for setting DistMap object. 1040 /// 1041 /// \ref named-func-param "Named parameter" 1042 ///for setting DistMap object. 1037 1043 template<class T> 1038 1044 DfsWizard<SetDistMapBase<T> > distMap(const T &t) … … 1048 1054 SetProcessedMapBase(const TR &b) : TR(b) {} 1049 1055 }; 1050 1051 ///\brief \ref named-func-param "Named parameter" for setting 1052 ///the processed map. 1053 /// 1054 ///\ref named-templ-param "Named parameter" function for setting 1055 ///the map that indicates which nodes are processed. 1056 ///\brief \ref named-func-param "Named parameter" 1057 ///for setting ProcessedMap object. 1058 /// 1059 /// \ref named-func-param "Named parameter" 1060 ///for setting ProcessedMap object. 1056 1061 template<class T> 1057 1062 DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1204 1209 /// 1205 1210 /// The type of the map that indicates which nodes are reached. 1206 /// It must conform tothe \ref concepts::ReadWriteMap "ReadWriteMap" concept.1211 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 1207 1212 typedef typename Digraph::template NodeMap<bool> ReachedMap; 1208 1213 … … 1365 1370 /// The simplest way to execute the DFS algorithm is to use one of the 1366 1371 /// member functions called \ref run(Node) "run()".\n 1367 /// If you need better control on the execution,you have to call1368 /// \ref init() first, then you can add a source node with \ref addSource()1372 /// If you need more control on the execution, first you have to call 1373 /// \ref init(), then you can add a source node with \ref addSource() 1369 1374 /// and perform the actual computation with \ref start(). 1370 1375 /// This procedure can be repeated if there are nodes that have not … … 1616 1621 ///@{ 1617 1622 1618 /// \brief Checks if the givennode is reached from the root(s).1623 /// \brief Checks if a node is reached from the root(s). 1619 1624 /// 1620 1625 /// Returns \c true if \c v is reached from the root(s). -
lemon/dijkstra.h
r764 r631 71 71 72 72 ///The type of the map that stores the arc lengths. 73 ///It must conform tothe \ref concepts::ReadMap "ReadMap" concept.73 ///It must meet the \ref concepts::ReadMap "ReadMap" concept. 74 74 typedef LEN LengthMap; 75 ///The type of the arc lengths.75 ///The type of the length of the arcs. 76 76 typedef typename LEN::Value Value; 77 77 … … 117 117 ///The type of the map that stores the predecessor 118 118 ///arcs of the shortest paths. 119 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.119 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 120 120 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 121 121 ///Instantiates a \c PredMap. … … 132 132 133 133 ///The type of the map that indicates which nodes are processed. 134 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.134 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 135 135 ///By default it is a NullMap. 136 136 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 152 152 153 153 ///The type of the map that stores the distances of the nodes. 154 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.154 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 155 155 typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap; 156 156 ///Instantiates a \c DistMap. … … 169 169 /// \ingroup shortest_path 170 170 ///This class provides an efficient implementation of the %Dijkstra algorithm. 171 ///172 ///The %Dijkstra algorithm solves the single-source shortest path problem173 ///when all arc lengths are non-negative. If there are negative lengths,174 ///the BellmanFord algorithm should be used instead.175 171 /// 176 172 ///The arc lengths are passed to the algorithm using a … … 206 202 typedef typename TR::Digraph Digraph; 207 203 208 ///The type of the arc lengths.204 ///The type of the length of the arcs. 209 205 typedef typename TR::LengthMap::Value Value; 210 206 ///The type of the map that stores the arc lengths. … … 309 305 ///\ref named-templ-param "Named parameter" for setting 310 306 ///\c PredMap type. 311 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.307 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 312 308 template <class T> 313 309 struct SetPredMap … … 330 326 ///\ref named-templ-param "Named parameter" for setting 331 327 ///\c DistMap type. 332 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.328 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 333 329 template <class T> 334 330 struct SetDistMap … … 351 347 ///\ref named-templ-param "Named parameter" for setting 352 348 ///\c ProcessedMap type. 353 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.349 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 354 350 template <class T> 355 351 struct SetProcessedMap … … 448 444 ///\ref named-templ-param "Named parameter" for setting 449 445 ///\c OperationTraits type. 450 /// For more information see \ref DijkstraDefaultOperationTraits.451 446 template <class T> 452 447 struct SetOperationTraits … … 590 585 ///The simplest way to execute the %Dijkstra algorithm is to use 591 586 ///one of the member functions called \ref run(Node) "run()".\n 592 ///If you need better control on the execution,you have to call593 ///\ref init() first, then you can add several source nodes with587 ///If you need more control on the execution, first you have to call 588 ///\ref init(), then you can add several source nodes with 594 589 ///\ref addSource(). Finally the actual path computation can be 595 590 ///performed with one of the \ref start() functions. … … 807 802 ///The results of the %Dijkstra algorithm can be obtained using these 808 803 ///functions.\n 809 ///Either \ref run(Node) "run()" or \ref init() should be called804 ///Either \ref run(Node) "run()" or \ref start() should be called 810 805 ///before using them. 811 806 812 807 ///@{ 813 808 814 ///The shortest path to the givennode.815 816 ///Returns the shortest path to the given node from the root(s).809 ///The shortest path to a node. 810 811 ///Returns the shortest path to a node. 817 812 /// 818 813 ///\warning \c t should be reached from the root(s). … … 822 817 Path path(Node t) const { return Path(*G, *_pred, t); } 823 818 824 ///The distance of the givennode from the root(s).825 826 ///Returns the distance of the givennode from the root(s).819 ///The distance of a node from the root(s). 820 821 ///Returns the distance of a node from the root(s). 827 822 /// 828 823 ///\warning If node \c v is not reached from the root(s), then … … 833 828 Value dist(Node v) const { return (*_dist)[v]; } 834 829 835 ///\brief Returns the 'previous arc' of the shortest path tree for 836 ///the given node. 837 /// 830 ///Returns the 'previous arc' of the shortest path tree for a node. 831 838 832 ///This function returns the 'previous arc' of the shortest path 839 833 ///tree for the node \c v, i.e. it returns the last arc of a … … 842 836 /// 843 837 ///The shortest path tree used here is equal to the shortest path 844 ///tree used in \ref predNode() and \ref predMap().838 ///tree used in \ref predNode(). 845 839 /// 846 840 ///\pre Either \ref run(Node) "run()" or \ref init() … … 848 842 Arc predArc(Node v) const { return (*_pred)[v]; } 849 843 850 ///\brief Returns the 'previous node' of the shortest path tree for 851 ///the given node. 852 /// 844 ///Returns the 'previous node' of the shortest path tree for a node. 845 853 846 ///This function returns the 'previous node' of the shortest path 854 847 ///tree for the node \c v, i.e. it returns the last but one node 855 /// ofa shortest path from a root to \c v. It is \c INVALID848 ///from a shortest path from a root to \c v. It is \c INVALID 856 849 ///if \c v is not reached from the root(s) or if \c v is a root. 857 850 /// 858 851 ///The shortest path tree used here is equal to the shortest path 859 ///tree used in \ref predArc() and \ref predMap().852 ///tree used in \ref predArc(). 860 853 /// 861 854 ///\pre Either \ref run(Node) "run()" or \ref init() … … 878 871 /// 879 872 ///Returns a const reference to the node map that stores the predecessor 880 ///arcs, which form the shortest path tree (forest).873 ///arcs, which form the shortest path tree. 881 874 /// 882 875 ///\pre Either \ref run(Node) "run()" or \ref init() … … 884 877 const PredMap &predMap() const { return *_pred;} 885 878 886 ///Checks if the givennode is reached from the root(s).879 ///Checks if a node is reached from the root(s). 887 880 888 881 ///Returns \c true if \c v is reached from the root(s). … … 903 896 Heap::POST_HEAP; } 904 897 905 ///The current distance of the givennode from the root(s).906 907 ///Returns the current distance of the givennode from the root(s).898 ///The current distance of a node from the root(s). 899 900 ///Returns the current distance of a node from the root(s). 908 901 ///It may be decreased in the following processes. 909 902 /// … … 932 925 933 926 ///The type of the map that stores the arc lengths. 934 ///It must conform tothe \ref concepts::ReadMap "ReadMap" concept.927 ///It must meet the \ref concepts::ReadMap "ReadMap" concept. 935 928 typedef LEN LengthMap; 936 ///The type of the arc lengths.929 ///The type of the length of the arcs. 937 930 typedef typename LEN::Value Value; 938 931 … … 981 974 ///The type of the map that stores the predecessor 982 975 ///arcs of the shortest paths. 983 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.976 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 984 977 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 985 978 ///Instantiates a PredMap. … … 996 989 997 990 ///The type of the map that indicates which nodes are processed. 998 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.991 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 999 992 ///By default it is a NullMap. 1000 993 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 1016 1009 1017 1010 ///The type of the map that stores the distances of the nodes. 1018 ///It must conform tothe \ref concepts::WriteMap "WriteMap" concept.1011 ///It must meet the \ref concepts::WriteMap "WriteMap" concept. 1019 1012 typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap; 1020 1013 ///Instantiates a DistMap. … … 1031 1024 1032 1025 ///The type of the shortest paths. 1033 ///It must conform tothe \ref concepts::Path "Path" concept.1026 ///It must meet the \ref concepts::Path "Path" concept. 1034 1027 typedef lemon::Path<Digraph> Path; 1035 1028 }; … … 1037 1030 /// Default traits class used by DijkstraWizard 1038 1031 1039 /// Default traits class used by DijkstraWizard. 1040 /// \tparam GR The type of the digraph. 1041 /// \tparam LEN The type of the length map. 1032 /// To make it easier to use Dijkstra algorithm 1033 /// we have created a wizard class. 1034 /// This \ref DijkstraWizard class needs default traits, 1035 /// as well as the \ref Dijkstra class. 1036 /// The \ref DijkstraWizardBase is a class to be the default traits of the 1037 /// \ref DijkstraWizard class. 1042 1038 template<typename GR, typename LEN> 1043 1039 class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN> … … 1098 1094 typedef TR Base; 1099 1095 1096 ///The type of the digraph the algorithm runs on. 1100 1097 typedef typename TR::Digraph Digraph; 1101 1098 … … 1105 1102 typedef typename Digraph::OutArcIt OutArcIt; 1106 1103 1104 ///The type of the map that stores the arc lengths. 1107 1105 typedef typename TR::LengthMap LengthMap; 1106 ///The type of the length of the arcs. 1108 1107 typedef typename LengthMap::Value Value; 1108 ///\brief The type of the map that stores the predecessor 1109 ///arcs of the shortest paths. 1109 1110 typedef typename TR::PredMap PredMap; 1111 ///The type of the map that stores the distances of the nodes. 1110 1112 typedef typename TR::DistMap DistMap; 1113 ///The type of the map that indicates which nodes are processed. 1111 1114 typedef typename TR::ProcessedMap ProcessedMap; 1115 ///The type of the shortest paths 1112 1116 typedef typename TR::Path Path; 1117 ///The heap type used by the dijkstra algorithm. 1113 1118 typedef typename TR::Heap Heap; 1114 1119 … … 1182 1187 SetPredMapBase(const TR &b) : TR(b) {} 1183 1188 }; 1184 1185 ///\brief \ref named-templ-param "Named parameter" for setting 1186 ///the predecessor map. 1187 /// 1188 ///\ref named-templ-param "Named parameter" function for setting 1189 ///the map that stores the predecessor arcs of the nodes. 1189 ///\brief \ref named-func-param "Named parameter" 1190 ///for setting PredMap object. 1191 /// 1192 ///\ref named-func-param "Named parameter" 1193 ///for setting PredMap object. 1190 1194 template<class T> 1191 1195 DijkstraWizard<SetPredMapBase<T> > predMap(const T &t) … … 1201 1205 SetDistMapBase(const TR &b) : TR(b) {} 1202 1206 }; 1203 1204 ///\brief \ref named-templ-param "Named parameter" for setting 1205 ///the distance map. 1206 /// 1207 ///\ref named-templ-param "Named parameter" function for setting 1208 ///the map that stores the distances of the nodes calculated 1209 ///by the algorithm. 1207 ///\brief \ref named-func-param "Named parameter" 1208 ///for setting DistMap object. 1209 /// 1210 ///\ref named-func-param "Named parameter" 1211 ///for setting DistMap object. 1210 1212 template<class T> 1211 1213 DijkstraWizard<SetDistMapBase<T> > distMap(const T &t) … … 1221 1223 SetProcessedMapBase(const TR &b) : TR(b) {} 1222 1224 }; 1223 1224 ///\brief \ref named-func-param "Named parameter" for setting 1225 ///the processed map. 1226 /// 1227 ///\ref named-templ-param "Named parameter" function for setting 1228 ///the map that indicates which nodes are processed. 1225 ///\brief \ref named-func-param "Named parameter" 1226 ///for setting ProcessedMap object. 1227 /// 1228 /// \ref named-func-param "Named parameter" 1229 ///for setting ProcessedMap object. 1229 1230 template<class T> 1230 1231 DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1239 1240 SetPathBase(const TR &b) : TR(b) {} 1240 1241 }; 1241 1242 1242 ///\brief \ref named-func-param "Named parameter" 1243 1243 ///for getting the shortest path to the target node. -
lemon/dim2.h
r761 r463 22 22 #include <iostream> 23 23 24 ///\ingroup geomdat24 ///\ingroup misc 25 25 ///\file 26 26 ///\brief A simple two dimensional vector and a bounding box implementation 27 /// 28 /// The class \ref lemon::dim2::Point "dim2::Point" implements 29 /// a two dimensional vector with the usual operations. 30 /// 31 /// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine 32 /// the rectangular bounding box of a set of 33 /// \ref lemon::dim2::Point "dim2::Point"'s. 27 34 28 35 namespace lemon { … … 34 41 namespace dim2 { 35 42 36 /// \addtogroup geomdat43 /// \addtogroup misc 37 44 /// @{ 38 45 -
lemon/fib_heap.h
r758 r730 21 21 22 22 ///\file 23 ///\ingroup heaps24 ///\brief Fibonacci heap implementation.23 ///\ingroup auxdat 24 ///\brief Fibonacci Heap implementation. 25 25 26 26 #include <vector> 27 #include <utility>28 27 #include <functional> 29 28 #include <lemon/math.h> … … 31 30 namespace lemon { 32 31 33 /// \ingroup heaps32 /// \ingroup auxdat 34 33 /// 35 /// \brief Fibonacci heap data structure.34 ///\brief Fibonacci Heap. 36 35 /// 37 /// This class implements the \e Fibonacci \e heap data structure. 38 /// It fully conforms to the \ref concepts::Heap "heap concept". 36 ///This class implements the \e Fibonacci \e heap data structure. A \e heap 37 ///is a data structure for storing items with specified values called \e 38 ///priorities in such a way that finding the item with minimum priority is 39 ///efficient. \c CMP specifies the ordering of the priorities. In a heap 40 ///one can change the priority of an item, add or erase an item, etc. 39 41 /// 40 /// The methods \ref increase() and \ref erase() are not efficient in a41 /// Fibonacci heap. In case of many calls of these operations, it is42 /// better to use other heap structure, e.g.\ref BinHeap "binary heap".42 ///The methods \ref increase and \ref erase are not efficient in a Fibonacci 43 ///heap. In case of many calls to these operations, it is better to use a 44 ///\ref BinHeap "binary heap". 43 45 /// 44 /// \tparam PR Type of the priorities of the items. 45 /// \tparam IM A read-writable item map with \c int values, used 46 /// internally to handle the cross references. 47 /// \tparam CMP A functor class for comparing the priorities. 48 /// The default is \c std::less<PR>. 46 ///\param PRIO Type of the priority of the items. 47 ///\param IM A read and writable Item int map, used internally 48 ///to handle the cross references. 49 ///\param CMP A class for the ordering of the priorities. The 50 ///default is \c std::less<PRIO>. 51 /// 52 ///\sa BinHeap 53 ///\sa Dijkstra 49 54 #ifdef DOXYGEN 50 template <typename PR , typename IM, typename CMP>55 template <typename PRIO, typename IM, typename CMP> 51 56 #else 52 template <typename PR , typename IM, typename CMP = std::less<PR> >57 template <typename PRIO, typename IM, typename CMP = std::less<PRIO> > 53 58 #endif 54 59 class FibHeap { 55 60 public: 56 57 /// Type of the item-int map. 61 ///\e 58 62 typedef IM ItemIntMap; 59 /// Type of the priorities.60 typedef PR Prio;61 /// Type of the items stored in the heap.63 ///\e 64 typedef PRIO Prio; 65 ///\e 62 66 typedef typename ItemIntMap::Key Item; 63 /// Type of the item-priority pairs.67 ///\e 64 68 typedef std::pair<Item,Prio> Pair; 65 /// Functor type for comparing the priorities.69 ///\e 66 70 typedef CMP Compare; 67 71 … … 77 81 public: 78 82 79 /// \brief Type to represent the states of the items.80 /// 81 /// Each item has a state associated to it. It canbe "in heap",82 /// "pre -heap" or "post-heap". The latter two are indifferent from the83 /// \brief Type to represent the items states. 84 /// 85 /// Each Item element have a state associated to it. It may be "in heap", 86 /// "pre heap" or "post heap". The latter two are indifferent from the 83 87 /// heap's point of view, but may be useful to the user. 84 88 /// … … 91 95 }; 92 96 93 /// \brief Constructor. 94 /// 95 /// Constructor. 96 /// \param map A map that assigns \c int values to the items. 97 /// It is used internally to handle the cross references. 98 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 97 /// \brief The constructor 98 /// 99 /// \c map should be given to the constructor, since it is 100 /// used internally to handle the cross references. 99 101 explicit FibHeap(ItemIntMap &map) 100 102 : _minimum(0), _iim(map), _num() {} 101 103 102 /// \brief Constructor. 103 /// 104 /// Constructor. 105 /// \param map A map that assigns \c int values to the items. 106 /// It is used internally to handle the cross references. 107 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item. 108 /// \param comp The function object used for comparing the priorities. 104 /// \brief The constructor 105 /// 106 /// \c map should be given to the constructor, since it is used 107 /// internally to handle the cross references. \c comp is an 108 /// object for ordering of the priorities. 109 109 FibHeap(ItemIntMap &map, const Compare &comp) 110 110 : _minimum(0), _iim(map), _comp(comp), _num() {} … … 112 112 /// \brief The number of items stored in the heap. 113 113 /// 114 /// This function returns the number of items stored in the heap.114 /// Returns the number of items stored in the heap. 115 115 int size() const { return _num; } 116 116 117 /// \brief Check if the heap is empty.118 /// 119 /// This function returns \c true if the heap is empty.117 /// \brief Checks if the heap stores no items. 118 /// 119 /// Returns \c true if and only if the heap stores no items. 120 120 bool empty() const { return _num==0; } 121 121 122 /// \brief Make the heap empty. 123 /// 124 /// This functon makes the heap empty. 125 /// It does not change the cross reference map. If you want to reuse 126 /// a heap that is not surely empty, you should first clear it and 127 /// then you should set the cross reference map to \c PRE_HEAP 128 /// for each item. 122 /// \brief Make empty this heap. 123 /// 124 /// Make empty this heap. It does not change the cross reference 125 /// map. If you want to reuse a heap what is not surely empty you 126 /// should first clear the heap and after that you should set the 127 /// cross reference map for each item to \c PRE_HEAP. 129 128 void clear() { 130 129 _data.clear(); _minimum = 0; _num = 0; 131 130 } 132 131 133 /// \brief Insert an item into the heap with the given priority. 134 /// 135 /// This function inserts the given item into the heap with the 136 /// given priority. 137 /// \param item The item to insert. 138 /// \param prio The priority of the item. 139 /// \pre \e item must not be stored in the heap. 140 void push (const Item& item, const Prio& prio) { 132 /// \brief \c item gets to the heap with priority \c value independently 133 /// if \c item was already there. 134 /// 135 /// This method calls \ref push(\c item, \c value) if \c item is not 136 /// stored in the heap and it calls \ref decrease(\c item, \c value) or 137 /// \ref increase(\c item, \c value) otherwise. 138 void set (const Item& item, const Prio& value) { 139 int i=_iim[item]; 140 if ( i >= 0 && _data[i].in ) { 141 if ( _comp(value, _data[i].prio) ) decrease(item, value); 142 if ( _comp(_data[i].prio, value) ) increase(item, value); 143 } else push(item, value); 144 } 145 146 /// \brief Adds \c item to the heap with priority \c value. 147 /// 148 /// Adds \c item to the heap with priority \c value. 149 /// \pre \c item must not be stored in the heap. 150 void push (const Item& item, const Prio& value) { 141 151 int i=_iim[item]; 142 152 if ( i < 0 ) { … … 159 169 _data[_minimum].right_neighbor=i; 160 170 _data[i].left_neighbor=_minimum; 161 if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;171 if ( _comp( value, _data[_minimum].prio) ) _minimum=i; 162 172 } else { 163 173 _data[i].right_neighbor=_data[i].left_neighbor=i; 164 174 _minimum=i; 165 175 } 166 _data[i].prio= prio;176 _data[i].prio=value; 167 177 ++_num; 168 178 } 169 179 170 /// \brief Return the item having minimum priority. 171 /// 172 /// This function returns the item having minimum priority. 173 /// \pre The heap must be non-empty. 180 /// \brief Returns the item with minimum priority relative to \c Compare. 181 /// 182 /// This method returns the item with minimum priority relative to \c 183 /// Compare. 184 /// \pre The heap must be nonempty. 174 185 Item top() const { return _data[_minimum].name; } 175 186 176 /// \brief The minimum priority. 177 /// 178 /// This function returns the minimum priority. 179 /// \pre The heap must be non-empty. 180 Prio prio() const { return _data[_minimum].prio; } 181 182 /// \brief Remove the item having minimum priority. 183 /// 184 /// This function removes the item having minimum priority. 187 /// \brief Returns the minimum priority relative to \c Compare. 188 /// 189 /// It returns the minimum priority relative to \c Compare. 190 /// \pre The heap must be nonempty. 191 const Prio& prio() const { return _data[_minimum].prio; } 192 193 /// \brief Returns the priority of \c item. 194 /// 195 /// It returns the priority of \c item. 196 /// \pre \c item must be in the heap. 197 const Prio& operator[](const Item& item) const { 198 return _data[_iim[item]].prio; 199 } 200 201 /// \brief Deletes the item with minimum priority relative to \c Compare. 202 /// 203 /// This method deletes the item with minimum priority relative to \c 204 /// Compare from the heap. 185 205 /// \pre The heap must be non-empty. 186 206 void pop() { … … 189 209 _data[_minimum].in=false; 190 210 if ( _data[_minimum].degree!=0 ) { 191 make Root(_data[_minimum].child);211 makeroot(_data[_minimum].child); 192 212 _minimum=_data[_minimum].child; 193 213 balance(); … … 202 222 int last_child=_data[child].left_neighbor; 203 223 204 make Root(child);224 makeroot(child); 205 225 206 226 _data[left].right_neighbor=child; … … 215 235 } 216 236 217 /// \brief Remove the given item from the heap. 218 /// 219 /// This function removes the given item from the heap if it is 220 /// already stored. 221 /// \param item The item to delete. 222 /// \pre \e item must be in the heap. 237 /// \brief Deletes \c item from the heap. 238 /// 239 /// This method deletes \c item from the heap, if \c item was already 240 /// stored in the heap. It is quite inefficient in Fibonacci heaps. 223 241 void erase (const Item& item) { 224 242 int i=_iim[item]; … … 235 253 } 236 254 237 /// \brief The priority of the given item. 238 /// 239 /// This function returns the priority of the given item. 240 /// \param item The item. 241 /// \pre \e item must be in the heap. 242 Prio operator[](const Item& item) const { 243 return _data[_iim[item]].prio; 244 } 245 246 /// \brief Set the priority of an item or insert it, if it is 247 /// not stored in the heap. 248 /// 249 /// This method sets the priority of the given item if it is 250 /// already stored in the heap. Otherwise it inserts the given 251 /// item into the heap with the given priority. 252 /// \param item The item. 253 /// \param prio The priority. 254 void set (const Item& item, const Prio& prio) { 255 /// \brief Decreases the priority of \c item to \c value. 256 /// 257 /// This method decreases the priority of \c item to \c value. 258 /// \pre \c item must be stored in the heap with priority at least \c 259 /// value relative to \c Compare. 260 void decrease (Item item, const Prio& value) { 255 261 int i=_iim[item]; 256 if ( i >= 0 && _data[i].in ) { 257 if ( _comp(prio, _data[i].prio) ) decrease(item, prio); 258 if ( _comp(_data[i].prio, prio) ) increase(item, prio); 259 } else push(item, prio); 260 } 261 262 /// \brief Decrease the priority of an item to the given value. 263 /// 264 /// This function decreases the priority of an item to the given value. 265 /// \param item The item. 266 /// \param prio The priority. 267 /// \pre \e item must be stored in the heap with priority at least \e prio. 268 void decrease (const Item& item, const Prio& prio) { 269 int i=_iim[item]; 270 _data[i].prio=prio; 262 _data[i].prio=value; 271 263 int p=_data[i].parent; 272 264 273 if ( p!=-1 && _comp( prio, _data[p].prio) ) {265 if ( p!=-1 && _comp(value, _data[p].prio) ) { 274 266 cut(i,p); 275 267 cascade(p); 276 268 } 277 if ( _comp(prio, _data[_minimum].prio) ) _minimum=i; 278 } 279 280 /// \brief Increase the priority of an item to the given value. 281 /// 282 /// This function increases the priority of an item to the given value. 283 /// \param item The item. 284 /// \param prio The priority. 285 /// \pre \e item must be stored in the heap with priority at most \e prio. 286 void increase (const Item& item, const Prio& prio) { 269 if ( _comp(value, _data[_minimum].prio) ) _minimum=i; 270 } 271 272 /// \brief Increases the priority of \c item to \c value. 273 /// 274 /// This method sets the priority of \c item to \c value. Though 275 /// there is no precondition on the priority of \c item, this 276 /// method should be used only if it is indeed necessary to increase 277 /// (relative to \c Compare) the priority of \c item, because this 278 /// method is inefficient. 279 void increase (Item item, const Prio& value) { 287 280 erase(item); 288 push(item, prio);289 } 290 291 /// \brief Return the state of an item. 292 /// 293 /// This method returns \c PRE_HEAP if the given item has never294 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,295 /// and \c POST_HEAP otherwise.296 /// In the latter case it is possible that the item will get back297 /// to the heap again.298 /// \param item The item.281 push(item, value); 282 } 283 284 285 /// \brief Returns if \c item is in, has already been in, or has never 286 /// been in the heap. 287 /// 288 /// This method returns PRE_HEAP if \c item has never been in the 289 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 290 /// otherwise. In the latter case it is possible that \c item will 291 /// get back to the heap again. 299 292 State state(const Item &item) const { 300 293 int i=_iim[item]; … … 306 299 } 307 300 308 /// \brief Set the state of anitem in the heap.309 /// 310 /// This function sets the state of the given item in the heap.311 /// It can be used to manually clear the heap when it is important312 /// to achive better timecomplexity.301 /// \brief Sets the state of the \c item in the heap. 302 /// 303 /// Sets the state of the \c item in the heap. It can be used to 304 /// manually clear the heap when it is important to achive the 305 /// better time _complexity. 313 306 /// \param i The item. 314 307 /// \param st The state. It should not be \c IN_HEAP. … … 373 366 } 374 367 375 void make Root(int c) {368 void makeroot(int c) { 376 369 int s=c; 377 370 do { -
lemon/full_graph.h
r827 r825 25 25 ///\ingroup graphs 26 26 ///\file 27 ///\brief Full Digraph and FullGraph classes.27 ///\brief FullGraph and FullDigraph classes. 28 28 29 29 namespace lemon { … … 149 149 /// \ingroup graphs 150 150 /// 151 /// \brief A directed full graph class. 152 /// 153 /// FullDigraph is a simple and fast implmenetation of directed full 154 /// (complete) graphs. It contains an arc from each node to each node 155 /// (including a loop for each node), therefore the number of arcs 156 /// is the square of the number of nodes. 157 /// This class is completely static and it needs constant memory space. 158 /// Thus you can neither add nor delete nodes or arcs, however 159 /// the structure can be resized using resize(). 160 /// 161 /// This type fully conforms to the \ref concepts::Digraph "Digraph concept". 162 /// Most of its member functions and nested classes are documented 163 /// only in the concept class. 164 /// 165 /// \note FullDigraph and FullGraph classes are very similar, 151 /// \brief A full digraph class. 152 /// 153 /// This is a simple and fast directed full graph implementation. 154 /// From each node go arcs to each node (including the source node), 155 /// therefore the number of the arcs in the digraph is the square of 156 /// the node number. This digraph type is completely static, so you 157 /// can neither add nor delete either arcs or nodes, and it needs 158 /// constant space in memory. 159 /// 160 /// This class fully conforms to the \ref concepts::Digraph 161 /// "Digraph concept". 162 /// 163 /// The \c FullDigraph and \c FullGraph classes are very similar, 166 164 /// but there are two differences. While this class conforms only 167 /// to the \ref concepts::Digraph "Digraph" concept, FullGraph168 /// c onforms to the \ref concepts::Graph "Graph" concept,169 /// moreover FullGraph does not contain a loopfor each170 /// node as this classdoes.165 /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph 166 /// class conforms to the \ref concepts::Graph "Graph" concept, 167 /// moreover \c FullGraph does not contain a loop arc for each 168 /// node as \c FullDigraph does. 171 169 /// 172 170 /// \sa FullGraph … … 176 174 public: 177 175 178 /// \brief Default constructor. 179 /// 180 /// Default constructor. The number of nodes and arcs will be zero. 176 /// \brief Constructor 181 177 FullDigraph() { construct(0); } 182 178 … … 189 185 /// \brief Resizes the digraph 190 186 /// 191 /// This function resizes the digraph. It fully destroysand192 /// rebuild s the structure, therefore the maps of the digraph will be187 /// Resizes the digraph. The function will fully destroy and 188 /// rebuild the digraph. This cause that the maps of the digraph will 193 189 /// reallocated automatically and the previous values will be lost. 194 190 void resize(int n) { … … 202 198 /// \brief Returns the node with the given index. 203 199 /// 204 /// Returns the node with the given index. Since this structure is205 /// completely static, the nodes can be indexed with integers from206 /// the range<tt>[0..nodeNum()-1]</tt>.200 /// Returns the node with the given index. Since it is a static 201 /// digraph its nodes can be indexed with integers from the range 202 /// <tt>[0..nodeNum()-1]</tt>. 207 203 /// \sa index() 208 204 Node operator()(int ix) const { return Parent::operator()(ix); } … … 210 206 /// \brief Returns the index of the given node. 211 207 /// 212 /// Returns the index of the given node. Since this structure is213 /// completely static, the nodes can be indexed with integers from214 /// the range<tt>[0..nodeNum()-1]</tt>.215 /// \sa operator() ()208 /// Returns the index of the given node. Since it is a static 209 /// digraph its nodes can be indexed with integers from the range 210 /// <tt>[0..nodeNum()-1]</tt>. 211 /// \sa operator() 216 212 static int index(const Node& node) { return Parent::index(node); } 217 213 … … 219 215 /// 220 216 /// Returns the arc connecting the given nodes. 221 Arc arc( Node u, Nodev) const {217 Arc arc(const Node& u, const Node& v) const { 222 218 return Parent::arc(u, v); 223 219 } … … 525 521 /// \brief An undirected full graph class. 526 522 /// 527 /// FullGraph is a simple and fast implmenetation of undirected full 528 /// (complete) graphs. It contains an edge between every distinct pair 529 /// of nodes, therefore the number of edges is <tt>n(n-1)/2</tt>. 530 /// This class is completely static and it needs constant memory space. 531 /// Thus you can neither add nor delete nodes or edges, however 532 /// the structure can be resized using resize(). 533 /// 534 /// This type fully conforms to the \ref concepts::Graph "Graph concept". 535 /// Most of its member functions and nested classes are documented 536 /// only in the concept class. 537 /// 538 /// \note FullDigraph and FullGraph classes are very similar, 539 /// but there are two differences. While FullDigraph 523 /// This is a simple and fast undirected full graph 524 /// implementation. From each node go edge to each other node, 525 /// therefore the number of edges in the graph is \f$n(n-1)/2\f$. 526 /// This graph type is completely static, so you can neither 527 /// add nor delete either edges or nodes, and it needs constant 528 /// space in memory. 529 /// 530 /// This class fully conforms to the \ref concepts::Graph "Graph concept". 531 /// 532 /// The \c FullGraph and \c FullDigraph classes are very similar, 533 /// but there are two differences. While the \c FullDigraph class 540 534 /// conforms only to the \ref concepts::Digraph "Digraph" concept, 541 535 /// this class conforms to the \ref concepts::Graph "Graph" concept, 542 /// moreover this class does not contain a loopfor each543 /// node as FullDigraph does.536 /// moreover \c FullGraph does not contain a loop arc for each 537 /// node as \c FullDigraph does. 544 538 /// 545 539 /// \sa FullDigraph … … 549 543 public: 550 544 551 /// \brief Default constructor. 552 /// 553 /// Default constructor. The number of nodes and edges will be zero. 545 /// \brief Constructor 554 546 FullGraph() { construct(0); } 555 547 … … 562 554 /// \brief Resizes the graph 563 555 /// 564 /// This function resizes the graph. It fully destroysand565 /// rebuild s the structure, therefore the maps of the graph will be556 /// Resizes the graph. The function will fully destroy and 557 /// rebuild the graph. This cause that the maps of the graph will 566 558 /// reallocated automatically and the previous values will be lost. 567 559 void resize(int n) { … … 577 569 /// \brief Returns the node with the given index. 578 570 /// 579 /// Returns the node with the given index. Since this structure is580 /// completely static, the nodes can be indexed with integers from581 /// the range<tt>[0..nodeNum()-1]</tt>.571 /// Returns the node with the given index. Since it is a static 572 /// graph its nodes can be indexed with integers from the range 573 /// <tt>[0..nodeNum()-1]</tt>. 582 574 /// \sa index() 583 575 Node operator()(int ix) const { return Parent::operator()(ix); } … … 585 577 /// \brief Returns the index of the given node. 586 578 /// 587 /// Returns the index of the given node. Since this structure is588 /// completely static, the nodes can be indexed with integers from589 /// the range<tt>[0..nodeNum()-1]</tt>.590 /// \sa operator() ()579 /// Returns the index of the given node. Since it is a static 580 /// graph its nodes can be indexed with integers from the range 581 /// <tt>[0..nodeNum()-1]</tt>. 582 /// \sa operator() 591 583 static int index(const Node& node) { return Parent::index(node); } 592 584 … … 594 586 /// 595 587 /// Returns the arc connecting the given nodes. 596 Arc arc( Node s, Nodet) const {588 Arc arc(const Node& s, const Node& t) const { 597 589 return Parent::arc(s, t); 598 590 } 599 591 600 /// \brief Returns the edge connect ingthe given nodes.601 /// 602 /// Returns the edge connect ingthe given nodes.603 Edge edge( Node u, Nodev) const {592 /// \brief Returns the edge connects the given nodes. 593 /// 594 /// Returns the edge connects the given nodes. 595 Edge edge(const Node& u, const Node& v) const { 604 596 return Parent::edge(u, v); 605 597 } -
lemon/glpk.cc
r793 r623 57 57 int i = glp_add_rows(lp, 1); 58 58 glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0); 59 return i;60 }61 62 int GlpkBase::_addRow(Value lo, ExprIterator b,63 ExprIterator e, Value up) {64 int i = glp_add_rows(lp, 1);65 66 if (lo == -INF) {67 if (up == INF) {68 glp_set_row_bnds(lp, i, GLP_FR, lo, up);69 } else {70 glp_set_row_bnds(lp, i, GLP_UP, lo, up);71 }72 } else {73 if (up == INF) {74 glp_set_row_bnds(lp, i, GLP_LO, lo, up);75 } else if (lo != up) {76 glp_set_row_bnds(lp, i, GLP_DB, lo, up);77 } else {78 glp_set_row_bnds(lp, i, GLP_FX, lo, up);79 }80 }81 82 std::vector<int> indexes;83 std::vector<Value> values;84 85 indexes.push_back(0);86 values.push_back(0);87 88 for(ExprIterator it = b; it != e; ++it) {89 indexes.push_back(it->first);90 values.push_back(it->second);91 }92 93 glp_set_mat_row(lp, i, values.size() - 1,94 &indexes.front(), &values.front());95 59 return i; 96 60 } -
lemon/glpk.h
r793 r697 55 55 virtual int _addCol(); 56 56 virtual int _addRow(); 57 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);58 57 59 58 virtual void _eraseCol(int i); -
lemon/gomory_hu.h
r760 r643 360 360 /// \c t. 361 361 /// \code 362 /// Gomor yHu<Graph> gom(g, capacities);362 /// GomoruHu<Graph> gom(g, capacities); 363 363 /// gom.run(); 364 364 /// int cnt=0; 365 /// for(Gomor yHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;365 /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt; 366 366 /// \endcode 367 367 class MinCutNodeIt … … 457 457 /// \c t. 458 458 /// \code 459 /// Gomor yHu<Graph> gom(g, capacities);459 /// GomoruHu<Graph> gom(g, capacities); 460 460 /// gom.run(); 461 461 /// int value=0; 462 /// for(Gomor yHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)462 /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) 463 463 /// value+=capacities[e]; 464 464 /// \endcode -
lemon/grid_graph.h
r782 r664 471 471 /// \brief Grid graph class 472 472 /// 473 /// GridGraphimplements a special graph type. The nodes of the474 /// graph can be indexed by two integer values \c (i,j)where \c i is475 /// in the range <tt>[0..width()-1]</tt> and j is in the range476 /// <tt>[0..height()-1]</tt>.Two nodes are connected in the graph if477 /// the ind ices differ exactly on one position and the difference is478 /// also exactly one. The nodes of the graph can be obtained by position479 /// using the \c operator()() function and the indices of the nodes can480 /// be obtained using\c pos(), \c col() and \c row() members. The outgoing473 /// This class implements a special graph type. The nodes of the 474 /// graph can be indexed by two integer \c (i,j) value where \c i is 475 /// in the \c [0..width()-1] range and j is in the \c 476 /// [0..height()-1] range. Two nodes are connected in the graph if 477 /// the indexes differ exactly on one position and exactly one is 478 /// the difference. The nodes of the graph can be indexed by position 479 /// with the \c operator()() function. The positions of the nodes can be 480 /// get with \c pos(), \c col() and \c row() members. The outgoing 481 481 /// arcs can be retrieved with the \c right(), \c up(), \c left() 482 482 /// and \c down() functions, where the bottom-left corner is the 483 483 /// origin. 484 ///485 /// This class is completely static and it needs constant memory space.486 /// Thus you can neither add nor delete nodes or edges, however487 /// the structure can be resized using resize().488 484 /// 489 485 /// \image html grid_graph.png … … 501 497 ///\endcode 502 498 /// 503 /// This type fully conforms to the \ref concepts::Graph "Graph concept". 504 /// Most of its member functions and nested classes are documented 505 /// only in the concept class. 499 /// This graph type fully conforms to the \ref concepts::Graph 500 /// "Graph concept". 506 501 class GridGraph : public ExtendedGridGraphBase { 507 502 typedef ExtendedGridGraphBase Parent; … … 509 504 public: 510 505 511 /// \brief Map to get the indices of the nodes as \ref dim2::Point 512 /// "dim2::Point<int>". 513 /// 514 /// Map to get the indices of the nodes as \ref dim2::Point 515 /// "dim2::Point<int>". 506 /// \brief Map to get the indices of the nodes as dim2::Point<int>. 507 /// 508 /// Map to get the indices of the nodes as dim2::Point<int>. 516 509 class IndexMap { 517 510 public: … … 522 515 523 516 /// \brief Constructor 517 /// 518 /// Constructor 524 519 IndexMap(const GridGraph& graph) : _graph(graph) {} 525 520 526 521 /// \brief The subscript operator 522 /// 523 /// The subscript operator. 527 524 Value operator[](Key key) const { 528 525 return _graph.pos(key); … … 544 541 545 542 /// \brief Constructor 543 /// 544 /// Constructor 546 545 ColMap(const GridGraph& graph) : _graph(graph) {} 547 546 548 547 /// \brief The subscript operator 548 /// 549 /// The subscript operator. 549 550 Value operator[](Key key) const { 550 551 return _graph.col(key); … … 566 567 567 568 /// \brief Constructor 569 /// 570 /// Constructor 568 571 RowMap(const GridGraph& graph) : _graph(graph) {} 569 572 570 573 /// \brief The subscript operator 574 /// 575 /// The subscript operator. 571 576 Value operator[](Key key) const { 572 577 return _graph.row(key); … … 579 584 /// \brief Constructor 580 585 /// 581 /// Construct a grid graph with thegiven size.586 /// Construct a grid graph with given size. 582 587 GridGraph(int width, int height) { construct(width, height); } 583 588 584 /// \brief Resizes the graph 585 /// 586 /// This function resizes the graph. It fully destroys and 587 /// rebuilds the structure, therefore the maps of the graph will be 588 /// reallocated automatically and the previous values will be lost. 589 /// \brief Resize the graph 590 /// 591 /// Resize the graph. The function will fully destroy and rebuild 592 /// the graph. This cause that the maps of the graph will 593 /// reallocated automatically and the previous values will be 594 /// lost. 589 595 void resize(int width, int height) { 590 596 Parent::notifier(Arc()).clear(); … … 604 610 } 605 611 606 /// \brief The column index of the node.612 /// \brief Gives back the column index of the node. 607 613 /// 608 614 /// Gives back the column index of the node. … … 611 617 } 612 618 613 /// \brief The row index of the node.619 /// \brief Gives back the row index of the node. 614 620 /// 615 621 /// Gives back the row index of the node. … … 618 624 } 619 625 620 /// \brief The position of the node.626 /// \brief Gives back the position of the node. 621 627 /// 622 628 /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair. … … 625 631 } 626 632 627 /// \brief The number of the columns.633 /// \brief Gives back the number of the columns. 628 634 /// 629 635 /// Gives back the number of the columns. … … 632 638 } 633 639 634 /// \brief The number of the rows.640 /// \brief Gives back the number of the rows. 635 641 /// 636 642 /// Gives back the number of the rows. … … 639 645 } 640 646 641 /// \brief The arc goes right from the node.647 /// \brief Gives back the arc goes right from the node. 642 648 /// 643 649 /// Gives back the arc goes right from the node. If there is not … … 647 653 } 648 654 649 /// \brief The arc goes left from the node.655 /// \brief Gives back the arc goes left from the node. 650 656 /// 651 657 /// Gives back the arc goes left from the node. If there is not … … 655 661 } 656 662 657 /// \brief The arc goes up from the node.663 /// \brief Gives back the arc goes up from the node. 658 664 /// 659 665 /// Gives back the arc goes up from the node. If there is not … … 663 669 } 664 670 665 /// \brief The arc goes down from the node.671 /// \brief Gives back the arc goes down from the node. 666 672 /// 667 673 /// Gives back the arc goes down from the node. If there is not -
lemon/hypercube_graph.h
r827 r825 283 283 /// \brief Hypercube graph class 284 284 /// 285 /// HypercubeGraph implements a special graph type. The nodes of the286 /// graph are indexed with integers havingat most \c dim binary digits.285 /// This class implements a special graph type. The nodes of the graph 286 /// are indiced with integers with at most \c dim binary digits. 287 287 /// Two nodes are connected in the graph if and only if their indices 288 288 /// differ only on one position in the binary form. 289 /// This class is completely static and it needs constant memory space.290 /// Thus you can neither add nor delete nodes or edges, however291 /// the structure can be resized using resize().292 ///293 /// This type fully conforms to the \ref concepts::Graph "Graph concept".294 /// Most of its member functions and nested classes are documented295 /// only in the concept class.296 289 /// 297 290 /// \note The type of the indices is chosen to \c int for efficiency 298 291 /// reasons. Thus the maximum dimension of this implementation is 26 299 292 /// (assuming that the size of \c int is 32 bit). 293 /// 294 /// This graph type fully conforms to the \ref concepts::Graph 295 /// "Graph concept". 300 296 class HypercubeGraph : public ExtendedHypercubeGraphBase { 301 297 typedef ExtendedHypercubeGraphBase Parent; … … 307 303 /// Constructs a hypercube graph with \c dim dimensions. 308 304 HypercubeGraph(int dim) { construct(dim); } 309 310 /// \brief Resizes the graph311 ///312 /// This function resizes the graph. It fully destroys and313 /// rebuilds the structure, therefore the maps of the graph will be314 /// reallocated automatically and the previous values will be lost.315 void resize(int dim) {316 Parent::notifier(Arc()).clear();317 Parent::notifier(Edge()).clear();318 Parent::notifier(Node()).clear();319 construct(dim);320 Parent::notifier(Node()).build();321 Parent::notifier(Edge()).build();322 Parent::notifier(Arc()).build();323 }324 305 325 306 /// \brief The number of dimensions. … … 340 321 /// 341 322 /// Gives back the dimension id of the given edge. 342 /// It is in the range <tt>[0..dim-1]</tt>.323 /// It is in the [0..dim-1] range. 343 324 int dimension(Edge edge) const { 344 325 return Parent::dimension(edge); … … 348 329 /// 349 330 /// Gives back the dimension id of the given arc. 350 /// It is in the range <tt>[0..dim-1]</tt>.331 /// It is in the [0..dim-1] range. 351 332 int dimension(Arc arc) const { 352 333 return Parent::dimension(arc); -
lemon/list_graph.h
r788 r664 22 22 ///\ingroup graphs 23 23 ///\file 24 ///\brief ListDigraph andListGraph classes.24 ///\brief ListDigraph, ListGraph classes. 25 25 26 26 #include <lemon/core.h> … … 32 32 33 33 namespace lemon { 34 35 class ListDigraph;36 34 37 35 class ListDigraphBase { … … 65 63 class Node { 66 64 friend class ListDigraphBase; 67 friend class ListDigraph;68 65 protected: 69 66 … … 81 78 class Arc { 82 79 friend class ListDigraphBase; 83 friend class ListDigraph;84 80 protected: 85 81 … … 121 117 int n; 122 118 for(n = first_node; 123 n != -1 && nodes[n].first_out== -1;119 n!=-1 && nodes[n].first_in == -1; 124 120 n = nodes[n].next) {} 125 arc.id = (n == -1) ? -1 : nodes[n].first_ out;121 arc.id = (n == -1) ? -1 : nodes[n].first_in; 126 122 } 127 123 128 124 void next(Arc& arc) const { 129 if (arcs[arc.id].next_ out!= -1) {130 arc.id = arcs[arc.id].next_ out;125 if (arcs[arc.id].next_in != -1) { 126 arc.id = arcs[arc.id].next_in; 131 127 } else { 132 128 int n; 133 for(n = nodes[arcs[arc.id]. source].next;134 n != -1 && nodes[n].first_out== -1;129 for(n = nodes[arcs[arc.id].target].next; 130 n!=-1 && nodes[n].first_in == -1; 135 131 n = nodes[n].next) {} 136 arc.id = (n == -1) ? -1 : nodes[n].first_ out;132 arc.id = (n == -1) ? -1 : nodes[n].first_in; 137 133 } 138 134 } … … 316 312 ///A general directed graph structure. 317 313 318 ///\ref ListDigraph is a versatile and fast directed graph319 ///implementation based on linked lists that are stored in314 ///\ref ListDigraph is a simple and fast <em>directed graph</em> 315 ///implementation based on static linked lists that are stored in 320 316 ///\c std::vector structures. 321 317 /// 322 /// This type fully conforms to the \ref concepts::Digraph "Digraph concept"323 ///a nd it also provides several useful additional functionalities.324 ///Most of itsmember functions and nested classes are documented318 ///It conforms to the \ref concepts::Digraph "Digraph concept" and it 319 ///also provides several useful additional functionalities. 320 ///Most of the member functions and nested classes are documented 325 321 ///only in the concept class. 326 322 /// 327 323 ///\sa concepts::Digraph 328 ///\sa ListGraph 324 329 325 class ListDigraph : public ExtendedListDigraphBase { 330 326 typedef ExtendedListDigraphBase Parent; 331 327 332 328 private: 333 /// Digraphs are \e not copy constructible. Use DigraphCopy instead. 329 ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. 330 331 ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. 332 /// 334 333 ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {}; 335 /// \brief Assignment of a digraph to another one is \e not allowed. 336 /// Use DigraphCopy instead. 334 ///\brief Assignment of ListDigraph to another one is \e not allowed. 335 ///Use copyDigraph() instead. 336 337 ///Assignment of ListDigraph to another one is \e not allowed. 338 ///Use copyDigraph() instead. 337 339 void operator=(const ListDigraph &) {} 338 340 public: … … 346 348 ///Add a new node to the digraph. 347 349 348 /// This function addsa new node to the digraph.350 ///Add a new node to the digraph. 349 351 ///\return The new node. 350 352 Node addNode() { return Parent::addNode(); } … … 352 354 ///Add a new arc to the digraph. 353 355 354 /// This function addsa new arc to the digraph with source node \c s356 ///Add a new arc to the digraph with source node \c s 355 357 ///and target node \c t. 356 358 ///\return The new arc. 357 Arc addArc( Node s, Nodet) {359 Arc addArc(const Node& s, const Node& t) { 358 360 return Parent::addArc(s, t); 359 361 } … … 361 363 ///\brief Erase a node from the digraph. 362 364 /// 363 ///This function erases the given node from the digraph. 364 void erase(Node n) { Parent::erase(n); } 365 ///Erase a node from the digraph. 366 /// 367 void erase(const Node& n) { Parent::erase(n); } 365 368 366 369 ///\brief Erase an arc from the digraph. 367 370 /// 368 ///This function erases the given arc from the digraph. 369 void erase(Arc a) { Parent::erase(a); } 371 ///Erase an arc from the digraph. 372 /// 373 void erase(const Arc& a) { Parent::erase(a); } 370 374 371 375 /// Node validity check 372 376 373 /// This function gives back \c true if the given node is valid, 374 /// i.e. it is a real node of the digraph. 375 /// 376 /// \warning A removed node could become valid again if new nodes are 377 /// added to the digraph. 377 /// This function gives back true if the given node is valid, 378 /// ie. it is a real node of the graph. 379 /// 380 /// \warning A Node pointing to a removed item 381 /// could become valid again later if new nodes are 382 /// added to the graph. 378 383 bool valid(Node n) const { return Parent::valid(n); } 379 384 380 385 /// Arc validity check 381 386 382 /// This function gives back \c true if the given arc is valid, 383 /// i.e. it is a real arc of the digraph. 384 /// 385 /// \warning A removed arc could become valid again if new arcs are 386 /// added to the digraph. 387 /// This function gives back true if the given arc is valid, 388 /// ie. it is a real arc of the graph. 389 /// 390 /// \warning An Arc pointing to a removed item 391 /// could become valid again later if new nodes are 392 /// added to the graph. 387 393 bool valid(Arc a) const { return Parent::valid(a); } 388 394 389 /// Change the target node of an arc 390 391 /// This function changes the target node of the given arc \c a to \c n. 392 /// 393 ///\note \c ArcIt and \c OutArcIt iterators referencing the changed 394 ///arc remain valid, however \c InArcIt iterators are invalidated. 395 /// Change the target of \c a to \c n 396 397 /// Change the target of \c a to \c n 398 /// 399 ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing 400 ///the changed arc remain valid. However <tt>InArcIt</tt>s are 401 ///invalidated. 395 402 /// 396 403 ///\warning This functionality cannot be used together with the Snapshot … … 399 406 Parent::changeTarget(a,n); 400 407 } 401 /// Change the source node of an arc 402 403 /// This function changes the source node of the given arc \c a to \c n. 404 /// 405 ///\note \c InArcIt iterators referencing the changed arc remain 406 ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated. 408 /// Change the source of \c a to \c n 409 410 /// Change the source of \c a to \c n 411 /// 412 ///\note The <tt>InArcIt</tt>s referencing the changed arc remain 413 ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are 414 ///invalidated. 407 415 /// 408 416 ///\warning This functionality cannot be used together with the Snapshot … … 412 420 } 413 421 414 /// Reversethe direction of an arc.415 416 /// This function reverses the direction of the given arc.417 /// \note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing418 /// the changed arc areinvalidated.422 /// Invert the direction of an arc. 423 424 ///\note The <tt>ArcIt</tt>s referencing the changed arc remain 425 ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are 426 ///invalidated. 419 427 /// 420 428 ///\warning This functionality cannot be used together with the Snapshot 421 429 ///feature. 422 void reverseArc(Arc a) { 423 Node t=target(a); 424 changeTarget(a,source(a)); 425 changeSource(a,t); 426 } 430 void reverseArc(Arc e) { 431 Node t=target(e); 432 changeTarget(e,source(e)); 433 changeSource(e,t); 434 } 435 436 /// Reserve memory for nodes. 437 438 /// Using this function it is possible to avoid the superfluous memory 439 /// allocation: if you know that the digraph you want to build will 440 /// be very large (e.g. it will contain millions of nodes and/or arcs) 441 /// then it is worth reserving space for this amount before starting 442 /// to build the digraph. 443 /// \sa reserveArc 444 void reserveNode(int n) { nodes.reserve(n); }; 445 446 /// Reserve memory for arcs. 447 448 /// Using this function it is possible to avoid the superfluous memory 449 /// allocation: if you know that the digraph you want to build will 450 /// be very large (e.g. it will contain millions of nodes and/or arcs) 451 /// then it is worth reserving space for this amount before starting 452 /// to build the digraph. 453 /// \sa reserveNode 454 void reserveArc(int m) { arcs.reserve(m); }; 427 455 428 456 ///Contract two nodes. 429 457 430 ///This function contracts the given two nodes. 431 ///Node \c v is removed, but instead of deleting its 432 ///incident arcs, they are joined to node \c u. 433 ///If the last parameter \c r is \c true (this is the default value), 434 ///then the newly created loops are removed. 435 /// 436 ///\note The moved arcs are joined to node \c u using changeSource() 437 ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are 438 ///invalidated for the outgoing arcs of node \c v and \c InArcIt 439 ///iterators are invalidated for the incomming arcs of \c v. 440 ///Moreover all iterators referencing node \c v or the removed 441 ///loops are also invalidated. Other iterators remain valid. 458 ///This function contracts two nodes. 459 ///Node \p b will be removed but instead of deleting 460 ///incident arcs, they will be joined to \p a. 461 ///The last parameter \p r controls whether to remove loops. \c true 462 ///means that loops will be removed. 463 /// 464 ///\note The <tt>ArcIt</tt>s referencing a moved arc remain 465 ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s 466 ///may be invalidated. 442 467 /// 443 468 ///\warning This functionality cannot be used together with the Snapshot 444 469 ///feature. 445 void contract(Node u, Node v, bool r = true)470 void contract(Node a, Node b, bool r = true) 446 471 { 447 for(OutArcIt e(*this, v);e!=INVALID;) {472 for(OutArcIt e(*this,b);e!=INVALID;) { 448 473 OutArcIt f=e; 449 474 ++f; 450 if(r && target(e)== u) erase(e);451 else changeSource(e, u);475 if(r && target(e)==a) erase(e); 476 else changeSource(e,a); 452 477 e=f; 453 478 } 454 for(InArcIt e(*this, v);e!=INVALID;) {479 for(InArcIt e(*this,b);e!=INVALID;) { 455 480 InArcIt f=e; 456 481 ++f; 457 if(r && source(e)== u) erase(e);458 else changeTarget(e, u);482 if(r && source(e)==a) erase(e); 483 else changeTarget(e,a); 459 484 e=f; 460 485 } 461 erase( v);486 erase(b); 462 487 } 463 488 464 489 ///Split a node. 465 490 466 ///This function splits the given node. First, a new node is added 467 ///to the digraph, then the source of each outgoing arc of node \c n 468 ///is moved to this new node. 469 ///If the second parameter \c connect is \c true (this is the default 470 ///value), then a new arc from node \c n to the newly created node 471 ///is also added. 491 ///This function splits a node. First a new node is added to the digraph, 492 ///then the source of each outgoing arc of \c n is moved to this new node. 493 ///If \c connect is \c true (this is the default value), then a new arc 494 ///from \c n to the newly created node is also added. 472 495 ///\return The newly created node. 473 496 /// 474 ///\note All iterators remain valid. 475 /// 476 ///\warning This functionality cannot be used together with the 497 ///\note The <tt>ArcIt</tt>s referencing a moved arc remain 498 ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may 499 ///be invalidated. 500 /// 501 ///\warning This functionality cannot be used in conjunction with the 477 502 ///Snapshot feature. 478 503 Node split(Node n, bool connect = true) { 479 504 Node b = addNode(); 480 nodes[b.id].first_out=nodes[n.id].first_out; 481 nodes[n.id].first_out=-1; 482 for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) { 483 arcs[i].source=b.id; 505 for(OutArcIt e(*this,n);e!=INVALID;) { 506 OutArcIt f=e; 507 ++f; 508 changeSource(e,b); 509 e=f; 484 510 } 485 511 if (connect) addArc(n,b); … … 489 515 ///Split an arc. 490 516 491 ///This function splits the given arc. First, a new node \c v is492 /// added to the digraph, then the target node of the original arc493 /// is set to \c v. Finally, an arc from \c v to the original target494 /// is added.517 ///This function splits an arc. First a new node \c b is added to 518 ///the digraph, then the original arc is re-targeted to \c 519 ///b. Finally an arc from \c b to the original target is added. 520 /// 495 521 ///\return The newly created node. 496 ///497 ///\note \c InArcIt iterators referencing the original arc are498 ///invalidated. Other iterators remain valid.499 522 /// 500 523 ///\warning This functionality cannot be used together with the 501 524 ///Snapshot feature. 502 Node split(Arc a) { 503 Node v = addNode(); 504 addArc(v,target(a)); 505 changeTarget(a,v); 506 return v; 507 } 508 509 ///Clear the digraph. 510 511 ///This function erases all nodes and arcs from the digraph. 512 /// 513 void clear() { 514 Parent::clear(); 515 } 516 517 /// Reserve memory for nodes. 518 519 /// Using this function, it is possible to avoid superfluous memory 520 /// allocation: if you know that the digraph you want to build will 521 /// be large (e.g. it will contain millions of nodes and/or arcs), 522 /// then it is worth reserving space for this amount before starting 523 /// to build the digraph. 524 /// \sa reserveArc() 525 void reserveNode(int n) { nodes.reserve(n); }; 526 527 /// Reserve memory for arcs. 528 529 /// Using this function, it is possible to avoid superfluous memory 530 /// allocation: if you know that the digraph you want to build will 531 /// be large (e.g. it will contain millions of nodes and/or arcs), 532 /// then it is worth reserving space for this amount before starting 533 /// to build the digraph. 534 /// \sa reserveNode() 535 void reserveArc(int m) { arcs.reserve(m); }; 525 Node split(Arc e) { 526 Node b = addNode(); 527 addArc(b,target(e)); 528 changeTarget(e,b); 529 return b; 530 } 536 531 537 532 /// \brief Class to make a snapshot of the digraph and restore … … 543 538 /// restore() function. 544 539 /// 545 /// \note After a state is restored, you cannot restore a later state, 546 /// i.e. you cannot add the removed nodes and arcs again using 547 /// another Snapshot instance. 548 /// 549 /// \warning Node and arc deletions and other modifications (e.g. 550 /// reversing, contracting, splitting arcs or nodes) cannot be 540 /// \warning Arc and node deletions and other modifications (e.g. 541 /// contracting, splitting, reversing arcs or nodes) cannot be 551 542 /// restored. These events invalidate the snapshot. 552 /// However the arcs and nodes that were added to the digraph after553 /// making the current snapshot can be removed without invalidating it.554 543 class Snapshot { 555 544 protected: … … 721 710 /// 722 711 /// Default constructor. 723 /// You have to call save() to actually make a snapshot.712 /// To actually make a snapshot you must call save(). 724 713 Snapshot() 725 714 : digraph(0), node_observer_proxy(*this), … … 728 717 /// \brief Constructor that immediately makes a snapshot. 729 718 /// 730 /// This constructor immediately makes a snapshot of the given digraph. 731 Snapshot(ListDigraph &gr) 719 /// This constructor immediately makes a snapshot of the digraph. 720 /// \param _digraph The digraph we make a snapshot of. 721 Snapshot(ListDigraph &_digraph) 732 722 : node_observer_proxy(*this), 733 723 arc_observer_proxy(*this) { 734 attach( gr);724 attach(_digraph); 735 725 } 736 726 737 727 /// \brief Make a snapshot. 738 728 /// 739 /// This function makes a snapshot of the given digraph. 740 /// It can be called more than once. In case of a repeated 729 /// Make a snapshot of the digraph. 730 /// 731 /// This function can be called more than once. In case of a repeated 741 732 /// call, the previous snapshot gets lost. 742 void save(ListDigraph &gr) { 733 /// \param _digraph The digraph we make the snapshot of. 734 void save(ListDigraph &_digraph) { 743 735 if (attached()) { 744 736 detach(); 745 737 clear(); 746 738 } 747 attach( gr);739 attach(_digraph); 748 740 } 749 741 750 742 /// \brief Undo the changes until the last snapshot. 751 /// 752 /// This function undos the changes until the last snapshot 753 /// created by save() or Snapshot(ListDigraph&). 754 /// 755 /// \warning This method invalidates the snapshot, i.e. repeated 756 /// restoring is not supported unless you call save() again. 743 // 744 /// Undo the changes until the last snapshot created by save(). 757 745 void restore() { 758 746 detach(); … … 768 756 } 769 757 770 /// \brief Returns \c true ifthe snapshot is valid.758 /// \brief Gives back true when the snapshot is valid. 771 759 /// 772 /// This function returns \c true ifthe snapshot is valid.760 /// Gives back true when the snapshot is valid. 773 761 bool valid() const { 774 762 return attached(); … … 807 795 808 796 typedef ListGraphBase Graph; 797 798 class Node; 799 class Arc; 800 class Edge; 809 801 810 802 class Node { … … 856 848 bool operator<(const Arc& arc) const {return id < arc.id;} 857 849 }; 850 851 858 852 859 853 ListGraphBase() … … 1171 1165 ///A general undirected graph structure. 1172 1166 1173 ///\ref ListGraph is a versatile and fast undirected graph1174 ///implementation based on linked lists that are stored in1167 ///\ref ListGraph is a simple and fast <em>undirected graph</em> 1168 ///implementation based on static linked lists that are stored in 1175 1169 ///\c std::vector structures. 1176 1170 /// 1177 /// This type fully conforms to the \ref concepts::Graph "Graph concept"1178 ///a nd it also provides several useful additional functionalities.1179 ///Most of itsmember functions and nested classes are documented1171 ///It conforms to the \ref concepts::Graph "Graph concept" and it 1172 ///also provides several useful additional functionalities. 1173 ///Most of the member functions and nested classes are documented 1180 1174 ///only in the concept class. 1181 1175 /// 1182 1176 ///\sa concepts::Graph 1183 ///\sa ListDigraph 1177 1184 1178 class ListGraph : public ExtendedListGraphBase { 1185 1179 typedef ExtendedListGraphBase Parent; 1186 1180 1187 1181 private: 1188 /// Graphs are \e not copy constructible. Use GraphCopy instead. 1182 ///ListGraph is \e not copy constructible. Use copyGraph() instead. 1183 1184 ///ListGraph is \e not copy constructible. Use copyGraph() instead. 1185 /// 1189 1186 ListGraph(const ListGraph &) :ExtendedListGraphBase() {}; 1190 /// \brief Assignment of a graph to another one is \e not allowed. 1191 /// Use GraphCopy instead. 1187 ///\brief Assignment of ListGraph to another one is \e not allowed. 1188 ///Use copyGraph() instead. 1189 1190 ///Assignment of ListGraph to another one is \e not allowed. 1191 ///Use copyGraph() instead. 1192 1192 void operator=(const ListGraph &) {} 1193 1193 public: … … 1202 1202 /// \brief Add a new node to the graph. 1203 1203 /// 1204 /// This function addsa new node to the graph.1204 /// Add a new node to the graph. 1205 1205 /// \return The new node. 1206 1206 Node addNode() { return Parent::addNode(); } … … 1208 1208 /// \brief Add a new edge to the graph. 1209 1209 /// 1210 /// This function adds a new edge to the graph between nodes 1211 /// \c u and \c v with inherent orientation from node \c u to 1212 /// node \c v. 1210 /// Add a new edge to the graph with source node \c s 1211 /// and target node \c t. 1213 1212 /// \return The new edge. 1214 Edge addEdge(Node u, Node v) { 1215 return Parent::addEdge(u, v); 1216 } 1217 1218 ///\brief Erase a node from the graph. 1219 /// 1220 /// This function erases the given node from the graph. 1221 void erase(Node n) { Parent::erase(n); } 1222 1223 ///\brief Erase an edge from the graph. 1224 /// 1225 /// This function erases the given edge from the graph. 1226 void erase(Edge e) { Parent::erase(e); } 1213 Edge addEdge(const Node& s, const Node& t) { 1214 return Parent::addEdge(s, t); 1215 } 1216 1217 /// \brief Erase a node from the graph. 1218 /// 1219 /// Erase a node from the graph. 1220 /// 1221 void erase(const Node& n) { Parent::erase(n); } 1222 1223 /// \brief Erase an edge from the graph. 1224 /// 1225 /// Erase an edge from the graph. 1226 /// 1227 void erase(const Edge& e) { Parent::erase(e); } 1227 1228 /// Node validity check 1228 1229 1229 /// This function gives back \c true if the given node is valid, 1230 /// i.e. it is a real node of the graph. 1231 /// 1232 /// \warning A removed node could become valid again if new nodes are 1230 /// This function gives back true if the given node is valid, 1231 /// ie. it is a real node of the graph. 1232 /// 1233 /// \warning A Node pointing to a removed item 1234 /// could become valid again later if new nodes are 1233 1235 /// added to the graph. 1234 1236 bool valid(Node n) const { return Parent::valid(n); } 1237 /// Arc validity check 1238 1239 /// This function gives back true if the given arc is valid, 1240 /// ie. it is a real arc of the graph. 1241 /// 1242 /// \warning An Arc pointing to a removed item 1243 /// could become valid again later if new edges are 1244 /// added to the graph. 1245 bool valid(Arc a) const { return Parent::valid(a); } 1235 1246 /// Edge validity check 1236 1247 1237 /// This function gives back \c true if the given edge is valid, 1238 /// i.e. it is a real edge of the graph. 1239 /// 1240 /// \warning A removed edge could become valid again if new edges are 1248 /// This function gives back true if the given edge is valid, 1249 /// ie. it is a real arc of the graph. 1250 /// 1251 /// \warning A Edge pointing to a removed item 1252 /// could become valid again later if new edges are 1241 1253 /// added to the graph. 1242 1254 bool valid(Edge e) const { return Parent::valid(e); } 1243 /// Arc validity check 1244 1245 /// This function gives back \c true if the given arc is valid, 1246 /// i.e. it is a real arc of the graph. 1247 /// 1248 /// \warning A removed arc could become valid again if new edges are 1249 /// added to the graph. 1250 bool valid(Arc a) const { return Parent::valid(a); } 1251 1252 /// \brief Change the first node of an edge. 1253 /// 1254 /// This function changes the first node of the given edge \c e to \c n. 1255 /// 1256 ///\note \c EdgeIt and \c ArcIt iterators referencing the 1257 ///changed edge are invalidated and all other iterators whose 1258 ///base node is the changed node are also invalidated. 1255 /// \brief Change the end \c u of \c e to \c n 1256 /// 1257 /// This function changes the end \c u of \c e to node \c n. 1258 /// 1259 ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the 1260 ///changed edge are invalidated and if the changed node is the 1261 ///base node of an iterator then this iterator is also 1262 ///invalidated. 1259 1263 /// 1260 1264 ///\warning This functionality cannot be used together with the … … 1263 1267 Parent::changeU(e,n); 1264 1268 } 1265 /// \brief Change the second node of an edge. 1266 /// 1267 /// This function changes the second node of the given edge \c e to \c n. 1268 /// 1269 ///\note \c EdgeIt iterators referencing the changed edge remain 1270 ///valid, however \c ArcIt iterators referencing the changed edge and 1271 ///all other iterators whose base node is the changed node are also 1272 ///invalidated. 1269 /// \brief Change the end \c v of \c e to \c n 1270 /// 1271 /// This function changes the end \c v of \c e to \c n. 1272 /// 1273 ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain 1274 ///valid, however <tt>ArcIt</tt>s and if the changed node is the 1275 ///base node of an iterator then this iterator is invalidated. 1273 1276 /// 1274 1277 ///\warning This functionality cannot be used together with the … … 1277 1280 Parent::changeV(e,n); 1278 1281 } 1279 1280 1282 /// \brief Contract two nodes. 1281 1283 /// 1282 /// This function contracts the given two nodes. 1283 /// Node \c b is removed, but instead of deleting 1284 /// its incident edges, they are joined to node \c a. 1285 /// If the last parameter \c r is \c true (this is the default value), 1286 /// then the newly created loops are removed. 1287 /// 1288 /// \note The moved edges are joined to node \c a using changeU() 1289 /// or changeV(), thus all edge and arc iterators whose base node is 1290 /// \c b are invalidated. 1291 /// Moreover all iterators referencing node \c b or the removed 1292 /// loops are also invalidated. Other iterators remain valid. 1284 /// This function contracts two nodes. 1285 /// Node \p b will be removed but instead of deleting 1286 /// its neighboring arcs, they will be joined to \p a. 1287 /// The last parameter \p r controls whether to remove loops. \c true 1288 /// means that loops will be removed. 1289 /// 1290 /// \note The <tt>ArcIt</tt>s referencing a moved arc remain 1291 /// valid. 1293 1292 /// 1294 1293 ///\warning This functionality cannot be used together with the … … 1309 1308 } 1310 1309 1311 ///Clear the graph.1312 1313 ///This function erases all nodes and arcs from the graph.1314 ///1315 void clear() {1316 Parent::clear();1317 }1318 1319 /// Reserve memory for nodes.1320 1321 /// Using this function, it is possible to avoid superfluous memory1322 /// allocation: if you know that the graph you want to build will1323 /// be large (e.g. it will contain millions of nodes and/or edges),1324 /// then it is worth reserving space for this amount before starting1325 /// to build the graph.1326 /// \sa reserveEdge()1327 void reserveNode(int n) { nodes.reserve(n); };1328 1329 /// Reserve memory for edges.1330 1331 /// Using this function, it is possible to avoid superfluous memory1332 /// allocation: if you know that the graph you want to build will1333 /// be large (e.g. it will contain millions of nodes and/or edges),1334 /// then it is worth reserving space for this amount before starting1335 /// to build the graph.1336 /// \sa reserveNode()1337 void reserveEdge(int m) { arcs.reserve(2 * m); };1338 1310 1339 1311 /// \brief Class to make a snapshot of the graph and restore … … 1345 1317 /// using the restore() function. 1346 1318 /// 1347 /// \note After a state is restored, you cannot restore a later state, 1348 /// i.e. you cannot add the removed nodes and edges again using 1349 /// another Snapshot instance. 1350 /// 1351 /// \warning Node and edge deletions and other modifications 1352 /// (e.g. changing the end-nodes of edges or contracting nodes) 1353 /// cannot be restored. These events invalidate the snapshot. 1354 /// However the edges and nodes that were added to the graph after 1355 /// making the current snapshot can be removed without invalidating it. 1319 /// \warning Edge and node deletions and other modifications 1320 /// (e.g. changing nodes of edges, contracting nodes) cannot be 1321 /// restored. These events invalidate the snapshot. 1356 1322 class Snapshot { 1357 1323 protected: … … 1523 1489 /// 1524 1490 /// Default constructor. 1525 /// You have to call save() to actually make a snapshot.1491 /// To actually make a snapshot you must call save(). 1526 1492 Snapshot() 1527 1493 : graph(0), node_observer_proxy(*this), … … 1530 1496 /// \brief Constructor that immediately makes a snapshot. 1531 1497 /// 1532 /// This constructor immediately makes a snapshot of the given graph. 1533 Snapshot(ListGraph &gr) 1498 /// This constructor immediately makes a snapshot of the graph. 1499 /// \param _graph The graph we make a snapshot of. 1500 Snapshot(ListGraph &_graph) 1534 1501 : node_observer_proxy(*this), 1535 1502 edge_observer_proxy(*this) { 1536 attach( gr);1503 attach(_graph); 1537 1504 } 1538 1505 1539 1506 /// \brief Make a snapshot. 1540 1507 /// 1541 /// This function makes a snapshot of the given graph. 1542 /// It can be called more than once. In case of a repeated 1508 /// Make a snapshot of the graph. 1509 /// 1510 /// This function can be called more than once. In case of a repeated 1543 1511 /// call, the previous snapshot gets lost. 1544 void save(ListGraph &gr) { 1512 /// \param _graph The graph we make the snapshot of. 1513 void save(ListGraph &_graph) { 1545 1514 if (attached()) { 1546 1515 detach(); 1547 1516 clear(); 1548 1517 } 1549 attach( gr);1518 attach(_graph); 1550 1519 } 1551 1520 1552 1521 /// \brief Undo the changes until the last snapshot. 1553 /// 1554 /// This function undos the changes until the last snapshot 1555 /// created by save() or Snapshot(ListGraph&). 1556 /// 1557 /// \warning This method invalidates the snapshot, i.e. repeated 1558 /// restoring is not supported unless you call save() again. 1522 // 1523 /// Undo the changes until the last snapshot created by save(). 1559 1524 void restore() { 1560 1525 detach(); … … 1570 1535 } 1571 1536 1572 /// \brief Returns \c true ifthe snapshot is valid.1537 /// \brief Gives back true when the snapshot is valid. 1573 1538 /// 1574 /// This function returns \c true ifthe snapshot is valid.1539 /// Gives back true when the snapshot is valid. 1575 1540 bool valid() const { 1576 1541 return attached(); -
lemon/lp_base.h
r793 r631 944 944 virtual int _addRow() = 0; 945 945 946 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {947 int row = _addRow();948 _setRowCoeffs(row, b, e);949 _setRowLowerBound(row, l);950 _setRowUpperBound(row, u);951 return row;952 }953 954 946 virtual void _eraseCol(int col) = 0; 955 947 virtual void _eraseRow(int row) = 0; … … 1216 1208 ///\return The created row. 1217 1209 Row addRow(Value l,const Expr &e, Value u) { 1218 Row r; 1219 e.simplify(); 1220 r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols), 1221 ExprIterator(e.comps.end(), cols), u - *e)); 1210 Row r=addRow(); 1211 row(r,l,e,u); 1222 1212 return r; 1223 1213 } … … 1228 1218 ///\return The created row. 1229 1219 Row addRow(const Constr &c) { 1230 Row r; 1231 c.expr().simplify(); 1232 r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF, 1233 ExprIterator(c.expr().comps.begin(), cols), 1234 ExprIterator(c.expr().comps.end(), cols), 1235 c.upperBounded()?c.upperBound():INF)); 1220 Row r=addRow(); 1221 row(r,c); 1236 1222 return r; 1237 1223 } -
lemon/lp_skeleton.cc
r793 r623 29 29 30 30 int SkeletonSolverBase::_addRow() 31 {32 return ++row_num;33 }34 35 int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)36 31 { 37 32 return ++row_num; -
lemon/lp_skeleton.h
r793 r623 45 45 /// \e 46 46 virtual int _addRow(); 47 /// \e48 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);49 47 /// \e 50 48 virtual void _eraseCol(int i); -
lemon/maps.h
r773 r731 23 23 #include <functional> 24 24 #include <vector> 25 #include <map>26 25 27 26 #include <lemon/core.h> … … 30 29 ///\ingroup maps 31 30 ///\brief Miscellaneous property maps 31 32 #include <map> 32 33 33 34 namespace lemon { … … 57 58 /// but data written to it is not required (i.e. it will be sent to 58 59 /// <tt>/dev/null</tt>). 59 /// It conforms t o the \ref concepts::ReadWriteMap "ReadWriteMap" concept.60 /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 60 61 /// 61 62 /// \sa ConstMap … … 90 91 /// 91 92 /// In other aspects it is equivalent to \c NullMap. 92 /// So it conforms t o the \ref concepts::ReadWriteMap "ReadWriteMap"93 /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" 93 94 /// concept, but it absorbs the data written to it. 94 95 /// … … 159 160 /// 160 161 /// In other aspects it is equivalent to \c NullMap. 161 /// So it conforms t o the \ref concepts::ReadWriteMap "ReadWriteMap"162 /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap" 162 163 /// concept, but it absorbs the data written to it. 163 164 /// … … 233 234 /// It can be used with some data structures, for example 234 235 /// \c UnionFind, \c BinHeap, when the used items are small 235 /// integers. This map conforms t o the \ref concepts::ReferenceMap236 /// integers. This map conforms the \ref concepts::ReferenceMap 236 237 /// "ReferenceMap" concept. 237 238 /// … … 341 342 /// stored actually. This value can be different from the default 342 343 /// contructed value (i.e. \c %Value()). 343 /// This type conforms t o the \ref concepts::ReferenceMap "ReferenceMap"344 /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap" 344 345 /// concept. 345 346 /// … … 707 708 /// The \c Key type of it is inherited from \c M and the \c Value 708 709 /// type is \c V. 709 /// This type conforms t o the \ref concepts::ReadMap "ReadMap" concept.710 /// This type conforms the \ref concepts::ReadMap "ReadMap" concept. 710 711 /// 711 712 /// The simplest way of using this map is through the convertMap() … … 1790 1791 /// \code 1791 1792 /// std::vector<Node> v; 1792 /// dfs(g ).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);1793 /// dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run(); 1793 1794 /// \endcode 1794 1795 /// \code 1795 1796 /// std::vector<Node> v(countNodes(g)); 1796 /// dfs(g ).processedMap(loggerBoolMap(v.begin())).run(s);1797 /// dfs(g,s).processedMap(loggerBoolMap(v.begin())).run(); 1797 1798 /// \endcode 1798 1799 /// … … 1818 1819 /// 1819 1820 /// IdMap provides a unique and immutable id for each item of the 1820 /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 1821 /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 1821 1822 /// - \b unique: different items get different ids, 1822 1823 /// - \b immutable: the id of an item does not change (even if you … … 1826 1827 /// the items stored in the graph, which is returned by the \c id() 1827 1828 /// function of the graph. This map can be inverted with its member 1828 /// class \c InverseMap or with the \c operator() ()member.1829 /// class \c InverseMap or with the \c operator() member. 1829 1830 /// 1830 1831 /// \tparam GR The graph type. … … 1866 1867 public: 1867 1868 1868 /// \brief The inverse map type of IdMap. 1869 /// 1870 /// The inverse map type of IdMap. The subscript operator gives back 1871 /// an item by its id. 1872 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 1869 /// \brief This class represents the inverse of its owner (IdMap). 1870 /// 1871 /// This class represents the inverse of its owner (IdMap). 1873 1872 /// \see inverse() 1874 1873 class InverseMap { … … 1885 1884 explicit InverseMap(const IdMap& map) : _graph(map._graph) {} 1886 1885 1887 /// \brief Gives back an item byits id.1886 /// \brief Gives back the given item from its id. 1888 1887 /// 1889 /// Gives back an item byits id.1888 /// Gives back the given item from its id. 1890 1889 Item operator[](int id) const { return _graph->fromId(id, Item());} 1891 1890 … … 1900 1899 }; 1901 1900 1902 /// \brief Returns an \c IdMap class.1903 ///1904 /// This function just returns an \c IdMap class.1905 /// \relates IdMap1906 template <typename K, typename GR>1907 inline IdMap<GR, K> idMap(const GR& graph) {1908 return IdMap<GR, K>(graph);1909 }1910 1901 1911 1902 /// \brief General cross reference graph map type. … … 1914 1905 /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap) 1915 1906 /// and if a key is set to a new value, then stores it in the inverse map. 1916 /// The graph items can be accessed by their values either using 1917 /// \c InverseMap or \c operator()(), and the values of the map can be 1918 /// accessed with an STL compatible forward iterator (\c ValueIt). 1919 /// 1920 /// This map is intended to be used when all associated values are 1921 /// different (the map is actually invertable) or there are only a few 1922 /// items with the same value. 1923 /// Otherwise consider to use \c IterableValueMap, which is more 1924 /// suitable and more efficient for such cases. It provides iterators 1925 /// to traverse the items with the same associated value, however 1926 /// it does not have \c InverseMap. 1907 /// The values of the map can be accessed 1908 /// with stl compatible forward iterator. 1927 1909 /// 1928 1910 /// This type is not reference map, so it cannot be modified with … … 1965 1947 /// \brief Forward iterator for values. 1966 1948 /// 1967 /// This iterator is an STLcompatible forward1949 /// This iterator is an stl compatible forward 1968 1950 /// iterator on the values of the map. The values can 1969 1951 /// be accessed in the <tt>[beginValue, endValue)</tt> range. 1970 1952 /// They are considered with multiplicity, so each value is 1971 1953 /// traversed for each item it is assigned to. 1972 class ValueIt 1954 class ValueIterator 1973 1955 : public std::iterator<std::forward_iterator_tag, Value> { 1974 1956 friend class CrossRefMap; 1975 1957 private: 1976 ValueIt (typename Container::const_iterator _it)1958 ValueIterator(typename Container::const_iterator _it) 1977 1959 : it(_it) {} 1978 1960 public: 1979 1961 1980 /// Constructor 1981 ValueIt() {} 1982 1983 /// \e 1984 ValueIt& operator++() { ++it; return *this; } 1985 /// \e 1986 ValueIt operator++(int) { 1987 ValueIt tmp(*this); 1962 ValueIterator() {} 1963 1964 ValueIterator& operator++() { ++it; return *this; } 1965 ValueIterator operator++(int) { 1966 ValueIterator tmp(*this); 1988 1967 operator++(); 1989 1968 return tmp; 1990 1969 } 1991 1970 1992 /// \e1993 1971 const Value& operator*() const { return it->first; } 1994 /// \e1995 1972 const Value* operator->() const { return &(it->first); } 1996 1973 1997 /// \e 1998 bool operator==(ValueIt jt) const { return it == jt.it; } 1999 /// \e 2000 bool operator!=(ValueIt jt) const { return it != jt.it; } 1974 bool operator==(ValueIterator jt) const { return it == jt.it; } 1975 bool operator!=(ValueIterator jt) const { return it != jt.it; } 2001 1976 2002 1977 private: 2003 1978 typename Container::const_iterator it; 2004 1979 }; 2005 2006 /// Alias for \c ValueIt2007 typedef ValueIt ValueIterator;2008 1980 2009 1981 /// \brief Returns an iterator to the first value. 2010 1982 /// 2011 /// Returns an STLcompatible iterator to the1983 /// Returns an stl compatible iterator to the 2012 1984 /// first value of the map. The values of the 2013 1985 /// map can be accessed in the <tt>[beginValue, endValue)</tt> 2014 1986 /// range. 2015 ValueIt beginValue() const {2016 return ValueIt (_inv_map.begin());1987 ValueIterator beginValue() const { 1988 return ValueIterator(_inv_map.begin()); 2017 1989 } 2018 1990 2019 1991 /// \brief Returns an iterator after the last value. 2020 1992 /// 2021 /// Returns an STLcompatible iterator after the1993 /// Returns an stl compatible iterator after the 2022 1994 /// last value of the map. The values of the 2023 1995 /// map can be accessed in the <tt>[beginValue, endValue)</tt> 2024 1996 /// range. 2025 ValueIt endValue() const {2026 return ValueIt (_inv_map.end());1997 ValueIterator endValue() const { 1998 return ValueIterator(_inv_map.end()); 2027 1999 } 2028 2000 … … 2061 2033 typename Container::const_iterator it = _inv_map.find(val); 2062 2034 return it != _inv_map.end() ? it->second : INVALID; 2063 }2064 2065 /// \brief Returns the number of items with the given value.2066 ///2067 /// This function returns the number of items with the given value2068 /// associated with it.2069 int count(const Value &val) const {2070 return _inv_map.count(val);2071 2035 } 2072 2036 … … 2120 2084 public: 2121 2085 2122 /// \brief The inverse map type of CrossRefMap. 2123 /// 2124 /// The inverse map type of CrossRefMap. The subscript operator gives 2125 /// back an item by its value. 2126 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 2127 /// \see inverse() 2086 /// \brief The inverse map type. 2087 /// 2088 /// The inverse of this map. The subscript operator of the map 2089 /// gives back the item that was last assigned to the value. 2128 2090 class InverseMap { 2129 2091 public: … … 2152 2114 }; 2153 2115 2154 /// \brief Gives back the inverse of the map.2155 /// 2156 /// Gives back the inverse of the CrossRefMap.2116 /// \brief It gives back the read-only inverse map. 2117 /// 2118 /// It gives back the read-only inverse map. 2157 2119 InverseMap inverse() const { 2158 2120 return InverseMap(*this); … … 2161 2123 }; 2162 2124 2163 /// \brief Provides continuous and unique idfor the2125 /// \brief Provides continuous and unique ID for the 2164 2126 /// items of a graph. 2165 2127 /// 2166 2128 /// RangeIdMap provides a unique and continuous 2167 /// idfor each item of a given type (\c Node, \c Arc or2129 /// ID for each item of a given type (\c Node, \c Arc or 2168 2130 /// \c Edge) in a graph. This id is 2169 2131 /// - \b unique: different items get different ids, … … 2176 2138 /// the \c id() function of the graph or \ref IdMap. 2177 2139 /// This map can be inverted with its member class \c InverseMap, 2178 /// or with the \c operator() ()member.2140 /// or with the \c operator() member. 2179 2141 /// 2180 2142 /// \tparam GR The graph type. … … 2304 2266 } 2305 2267 2306 /// \brief Gives back the \e range \e id of the item2307 /// 2308 /// Gives back the \e range \e id of the item.2268 /// \brief Gives back the \e RangeId of the item 2269 /// 2270 /// Gives back the \e RangeId of the item. 2309 2271 int operator[](const Item& item) const { 2310 2272 return Map::operator[](item); 2311 2273 } 2312 2274 2313 /// \brief Gives back the item belonging to a \e range \e id2314 /// 2315 /// Gives back the item belonging to the given \e range \e id.2275 /// \brief Gives back the item belonging to a \e RangeId 2276 /// 2277 /// Gives back the item belonging to a \e RangeId. 2316 2278 Item operator()(int id) const { 2317 2279 return _inv_map[id]; … … 2327 2289 /// \brief The inverse map type of RangeIdMap. 2328 2290 /// 2329 /// The inverse map type of RangeIdMap. The subscript operator gives 2330 /// back an item by its \e range \e id. 2331 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 2291 /// The inverse map type of RangeIdMap. 2332 2292 class InverseMap { 2333 2293 public: … … 2347 2307 /// 2348 2308 /// Subscript operator. It gives back the item 2349 /// that the given \e range \e idcurrently belongs to.2309 /// that the descriptor currently belongs to. 2350 2310 Value operator[](const Key& key) const { 2351 2311 return _inverted(key); … … 2365 2325 /// \brief Gives back the inverse of the map. 2366 2326 /// 2367 /// Gives back the inverse of the RangeIdMap.2327 /// Gives back the inverse of the map. 2368 2328 const InverseMap inverse() const { 2369 2329 return InverseMap(*this); 2370 2330 } 2371 };2372 2373 /// \brief Returns a \c RangeIdMap class.2374 ///2375 /// This function just returns an \c RangeIdMap class.2376 /// \relates RangeIdMap2377 template <typename K, typename GR>2378 inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {2379 return RangeIdMap<GR, K>(graph);2380 }2381 2382 /// \brief Dynamic iterable \c bool map.2383 ///2384 /// This class provides a special graph map type which can store a2385 /// \c bool value for graph items (\c Node, \c Arc or \c Edge).2386 /// For both \c true and \c false values it is possible to iterate on2387 /// the keys mapped to the value.2388 ///2389 /// This type is a reference map, so it can be modified with the2390 /// subscript operator.2391 ///2392 /// \tparam GR The graph type.2393 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or2394 /// \c GR::Edge).2395 ///2396 /// \see IterableIntMap, IterableValueMap2397 /// \see CrossRefMap2398 template <typename GR, typename K>2399 class IterableBoolMap2400 : protected ItemSetTraits<GR, K>::template Map<int>::Type {2401 private:2402 typedef GR Graph;2403 2404 typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;2405 typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;2406 2407 std::vector<K> _array;2408 int _sep;2409 2410 public:2411 2412 /// Indicates that the map is reference map.2413 typedef True ReferenceMapTag;2414 2415 /// The key type2416 typedef K Key;2417 /// The value type2418 typedef bool Value;2419 /// The const reference type.2420 typedef const Value& ConstReference;2421 2422 private:2423 2424 int position(const Key& key) const {2425 return Parent::operator[](key);2426 }2427 2428 public:2429 2430 /// \brief Reference to the value of the map.2431 ///2432 /// This class is similar to the \c bool type. It can be converted to2433 /// \c bool and it provides the same operators.2434 class Reference {2435 friend class IterableBoolMap;2436 private:2437 Reference(IterableBoolMap& map, const Key& key)2438 : _key(key), _map(map) {}2439 public:2440 2441 Reference& operator=(const Reference& value) {2442 _map.set(_key, static_cast<bool>(value));2443 return *this;2444 }2445 2446 operator bool() const {2447 return static_cast<const IterableBoolMap&>(_map)[_key];2448 }2449 2450 Reference& operator=(bool value) {2451 _map.set(_key, value);2452 return *this;2453 }2454 Reference& operator&=(bool value) {2455 _map.set(_key, _map[_key] & value);2456 return *this;2457 }2458 Reference& operator|=(bool value) {2459 _map.set(_key, _map[_key] | value);2460 return *this;2461 }2462 Reference& operator^=(bool value) {2463 _map.set(_key, _map[_key] ^ value);2464 return *this;2465 }2466 private:2467 Key _key;2468 IterableBoolMap& _map;2469 };2470 2471 /// \brief Constructor of the map with a default value.2472 ///2473 /// Constructor of the map with a default value.2474 explicit IterableBoolMap(const Graph& graph, bool def = false)2475 : Parent(graph) {2476 typename Parent::Notifier* nf = Parent::notifier();2477 Key it;2478 for (nf->first(it); it != INVALID; nf->next(it)) {2479 Parent::set(it, _array.size());2480 _array.push_back(it);2481 }2482 _sep = (def ? _array.size() : 0);2483 }2484 2485 /// \brief Const subscript operator of the map.2486 ///2487 /// Const subscript operator of the map.2488 bool operator[](const Key& key) const {2489 return position(key) < _sep;2490 }2491 2492 /// \brief Subscript operator of the map.2493 ///2494 /// Subscript operator of the map.2495 Reference operator[](const Key& key) {2496 return Reference(*this, key);2497 }2498 2499 /// \brief Set operation of the map.2500 ///2501 /// Set operation of the map.2502 void set(const Key& key, bool value) {2503 int pos = position(key);2504 if (value) {2505 if (pos < _sep) return;2506 Key tmp = _array[_sep];2507 _array[_sep] = key;2508 Parent::set(key, _sep);2509 _array[pos] = tmp;2510 Parent::set(tmp, pos);2511 ++_sep;2512 } else {2513 if (pos >= _sep) return;2514 --_sep;2515 Key tmp = _array[_sep];2516 _array[_sep] = key;2517 Parent::set(key, _sep);2518 _array[pos] = tmp;2519 Parent::set(tmp, pos);2520 }2521 }2522 2523 /// \brief Set all items.2524 ///2525 /// Set all items in the map.2526 /// \note Constant time operation.2527 void setAll(bool value) {2528 _sep = (value ? _array.size() : 0);2529 }2530 2531 /// \brief Returns the number of the keys mapped to \c true.2532 ///2533 /// Returns the number of the keys mapped to \c true.2534 int trueNum() const {2535 return _sep;2536 }2537 2538 /// \brief Returns the number of the keys mapped to \c false.2539 ///2540 /// Returns the number of the keys mapped to \c false.2541 int falseNum() const {2542 return _array.size() - _sep;2543 }2544 2545 /// \brief Iterator for the keys mapped to \c true.2546 ///2547 /// Iterator for the keys mapped to \c true. It works2548 /// like a graph item iterator, it can be converted to2549 /// the key type of the map, incremented with \c ++ operator, and2550 /// if the iterator leaves the last valid key, it will be equal to2551 /// \c INVALID.2552 class TrueIt : public Key {2553 public:2554 typedef Key Parent;2555 2556 /// \brief Creates an iterator.2557 ///2558 /// Creates an iterator. It iterates on the2559 /// keys mapped to \c true.2560 /// \param map The IterableBoolMap.2561 explicit TrueIt(const IterableBoolMap& map)2562 : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),2563 _map(&map) {}2564 2565 /// \brief Invalid constructor \& conversion.2566 ///2567 /// This constructor initializes the iterator to be invalid.2568 /// \sa Invalid for more details.2569 TrueIt(Invalid) : Parent(INVALID), _map(0) {}2570 2571 /// \brief Increment operator.2572 ///2573 /// Increment operator.2574 TrueIt& operator++() {2575 int pos = _map->position(*this);2576 Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);2577 return *this;2578 }2579 2580 private:2581 const IterableBoolMap* _map;2582 };2583 2584 /// \brief Iterator for the keys mapped to \c false.2585 ///2586 /// Iterator for the keys mapped to \c false. It works2587 /// like a graph item iterator, it can be converted to2588 /// the key type of the map, incremented with \c ++ operator, and2589 /// if the iterator leaves the last valid key, it will be equal to2590 /// \c INVALID.2591 class FalseIt : public Key {2592 public:2593 typedef Key Parent;2594 2595 /// \brief Creates an iterator.2596 ///2597 /// Creates an iterator. It iterates on the2598 /// keys mapped to \c false.2599 /// \param map The IterableBoolMap.2600 explicit FalseIt(const IterableBoolMap& map)2601 : Parent(map._sep < int(map._array.size()) ?2602 map._array.back() : INVALID), _map(&map) {}2603 2604 /// \brief Invalid constructor \& conversion.2605 ///2606 /// This constructor initializes the iterator to be invalid.2607 /// \sa Invalid for more details.2608 FalseIt(Invalid) : Parent(INVALID), _map(0) {}2609 2610 /// \brief Increment operator.2611 ///2612 /// Increment operator.2613 FalseIt& operator++() {2614 int pos = _map->position(*this);2615 Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);2616 return *this;2617 }2618 2619 private:2620 const IterableBoolMap* _map;2621 };2622 2623 /// \brief Iterator for the keys mapped to a given value.2624 ///2625 /// Iterator for the keys mapped to a given value. It works2626 /// like a graph item iterator, it can be converted to2627 /// the key type of the map, incremented with \c ++ operator, and2628 /// if the iterator leaves the last valid key, it will be equal to2629 /// \c INVALID.2630 class ItemIt : public Key {2631 public:2632 typedef Key Parent;2633 2634 /// \brief Creates an iterator with a value.2635 ///2636 /// Creates an iterator with a value. It iterates on the2637 /// keys mapped to the given value.2638 /// \param map The IterableBoolMap.2639 /// \param value The value.2640 ItemIt(const IterableBoolMap& map, bool value)2641 : Parent(value ?2642 (map._sep > 0 ?2643 map._array[map._sep - 1] : INVALID) :2644 (map._sep < int(map._array.size()) ?2645 map._array.back() : INVALID)), _map(&map) {}2646 2647 /// \brief Invalid constructor \& conversion.2648 ///2649 /// This constructor initializes the iterator to be invalid.2650 /// \sa Invalid for more details.2651 ItemIt(Invalid) : Parent(INVALID), _map(0) {}2652 2653 /// \brief Increment operator.2654 ///2655 /// Increment operator.2656 ItemIt& operator++() {2657 int pos = _map->position(*this);2658 int _sep = pos >= _map->_sep ? _map->_sep : 0;2659 Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);2660 return *this;2661 }2662 2663 private:2664 const IterableBoolMap* _map;2665 };2666 2667 protected:2668 2669 virtual void add(const Key& key) {2670 Parent::add(key);2671 Parent::set(key, _array.size());2672 _array.push_back(key);2673 }2674 2675 virtual void add(const std::vector<Key>& keys) {2676 Parent::add(keys);2677 for (int i = 0; i < int(keys.size()); ++i) {2678 Parent::set(keys[i], _array.size());2679 _array.push_back(keys[i]);2680 }2681 }2682 2683 virtual void erase(const Key& key) {2684 int pos = position(key);2685 if (pos < _sep) {2686 --_sep;2687 Parent::set(_array[_sep], pos);2688 _array[pos] = _array[_sep];2689 Parent::set(_array.back(), _sep);2690 _array[_sep] = _array.back();2691 _array.pop_back();2692 } else {2693 Parent::set(_array.back(), pos);2694 _array[pos] = _array.back();2695 _array.pop_back();2696 }2697 Parent::erase(key);2698 }2699 2700 virtual void erase(const std::vector<Key>& keys) {2701 for (int i = 0; i < int(keys.size()); ++i) {2702 int pos = position(keys[i]);2703 if (pos < _sep) {2704 --_sep;2705 Parent::set(_array[_sep], pos);2706 _array[pos] = _array[_sep];2707 Parent::set(_array.back(), _sep);2708 _array[_sep] = _array.back();2709 _array.pop_back();2710 } else {2711 Parent::set(_array.back(), pos);2712 _array[pos] = _array.back();2713 _array.pop_back();2714 }2715 }2716 Parent::erase(keys);2717 }2718 2719 virtual void build() {2720 Parent::build();2721 typename Parent::Notifier* nf = Parent::notifier();2722 Key it;2723 for (nf->first(it); it != INVALID; nf->next(it)) {2724 Parent::set(it, _array.size());2725 _array.push_back(it);2726 }2727 _sep = 0;2728 }2729 2730 virtual void clear() {2731 _array.clear();2732 _sep = 0;2733 Parent::clear();2734 }2735 2736 };2737 2738 2739 namespace _maps_bits {2740 template <typename Item>2741 struct IterableIntMapNode {2742 IterableIntMapNode() : value(-1) {}2743 IterableIntMapNode(int _value) : value(_value) {}2744 Item prev, next;2745 int value;2746 };2747 }2748 2749 /// \brief Dynamic iterable integer map.2750 ///2751 /// This class provides a special graph map type which can store an2752 /// integer value for graph items (\c Node, \c Arc or \c Edge).2753 /// For each non-negative value it is possible to iterate on the keys2754 /// mapped to the value.2755 ///2756 /// This map is intended to be used with small integer values, for which2757 /// it is efficient, and supports iteration only for non-negative values.2758 /// If you need large values and/or iteration for negative integers,2759 /// consider to use \ref IterableValueMap instead.2760 ///2761 /// This type is a reference map, so it can be modified with the2762 /// subscript operator.2763 ///2764 /// \note The size of the data structure depends on the largest2765 /// value in the map.2766 ///2767 /// \tparam GR The graph type.2768 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or2769 /// \c GR::Edge).2770 ///2771 /// \see IterableBoolMap, IterableValueMap2772 /// \see CrossRefMap2773 template <typename GR, typename K>2774 class IterableIntMap2775 : protected ItemSetTraits<GR, K>::2776 template Map<_maps_bits::IterableIntMapNode<K> >::Type {2777 public:2778 typedef typename ItemSetTraits<GR, K>::2779 template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;2780 2781 /// The key type2782 typedef K Key;2783 /// The value type2784 typedef int Value;2785 /// The graph type2786 typedef GR Graph;2787 2788 /// \brief Constructor of the map.2789 ///2790 /// Constructor of the map. It sets all values to -1.2791 explicit IterableIntMap(const Graph& graph)2792 : Parent(graph) {}2793 2794 /// \brief Constructor of the map with a given value.2795 ///2796 /// Constructor of the map with a given value.2797 explicit IterableIntMap(const Graph& graph, int value)2798 : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {2799 if (value >= 0) {2800 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {2801 lace(it);2802 }2803 }2804 }2805 2806 private:2807 2808 void unlace(const Key& key) {2809 typename Parent::Value& node = Parent::operator[](key);2810 if (node.value < 0) return;2811 if (node.prev != INVALID) {2812 Parent::operator[](node.prev).next = node.next;2813 } else {2814 _first[node.value] = node.next;2815 }2816 if (node.next != INVALID) {2817 Parent::operator[](node.next).prev = node.prev;2818 }2819 while (!_first.empty() && _first.back() == INVALID) {2820 _first.pop_back();2821 }2822 }2823 2824 void lace(const Key& key) {2825 typename Parent::Value& node = Parent::operator[](key);2826 if (node.value < 0) return;2827 if (node.value >= int(_first.size())) {2828 _first.resize(node.value + 1, INVALID);2829 }2830 node.prev = INVALID;2831 node.next = _first[node.value];2832 if (node.next != INVALID) {2833 Parent::operator[](node.next).prev = key;2834 }2835 _first[node.value] = key;2836 }2837 2838 public:2839 2840 /// Indicates that the map is reference map.2841 typedef True ReferenceMapTag;2842 2843 /// \brief Reference to the value of the map.2844 ///2845 /// This class is similar to the \c int type. It can2846 /// be converted to \c int and it has the same operators.2847 class Reference {2848 friend class IterableIntMap;2849 private:2850 Reference(IterableIntMap& map, const Key& key)2851 : _key(key), _map(map) {}2852 public:2853 2854 Reference& operator=(const Reference& value) {2855 _map.set(_key, static_cast<const int&>(value));2856 return *this;2857 }2858 2859 operator const int&() const {2860 return static_cast<const IterableIntMap&>(_map)[_key];2861 }2862 2863 Reference& operator=(int value) {2864 _map.set(_key, value);2865 return *this;2866 }2867 Reference& operator++() {2868 _map.set(_key, _map[_key] + 1);2869 return *this;2870 }2871 int operator++(int) {2872 int value = _map[_key];2873 _map.set(_key, value + 1);2874 return value;2875 }2876 Reference& operator--() {2877 _map.set(_key, _map[_key] - 1);2878 return *this;2879 }2880 int operator--(int) {2881 int value = _map[_key];2882 _map.set(_key, value - 1);2883 return value;2884 }2885 Reference& operator+=(int value) {2886 _map.set(_key, _map[_key] + value);2887 return *this;2888 }2889 Reference& operator-=(int value) {2890 _map.set(_key, _map[_key] - value);2891 return *this;2892 }2893 Reference& operator*=(int value) {2894 _map.set(_key, _map[_key] * value);2895 return *this;2896 }2897 Reference& operator/=(int value) {2898 _map.set(_key, _map[_key] / value);2899 return *this;2900 }2901 Reference& operator%=(int value) {2902 _map.set(_key, _map[_key] % value);2903 return *this;2904 }2905 Reference& operator&=(int value) {2906 _map.set(_key, _map[_key] & value);2907 return *this;2908 }2909 Reference& operator|=(int value) {2910 _map.set(_key, _map[_key] | value);2911 return *this;2912 }2913 Reference& operator^=(int value) {2914 _map.set(_key, _map[_key] ^ value);2915 return *this;2916 }2917 Reference& operator<<=(int value) {2918 _map.set(_key, _map[_key] << value);2919 return *this;2920 }2921 Reference& operator>>=(int value) {2922 _map.set(_key, _map[_key] >> value);2923 return *this;2924 }2925 2926 private:2927 Key _key;2928 IterableIntMap& _map;2929 };2930 2931 /// The const reference type.2932 typedef const Value& ConstReference;2933 2934 /// \brief Gives back the maximal value plus one.2935 ///2936 /// Gives back the maximal value plus one.2937 int size() const {2938 return _first.size();2939 }2940 2941 /// \brief Set operation of the map.2942 ///2943 /// Set operation of the map.2944 void set(const Key& key, const Value& value) {2945 unlace(key);2946 Parent::operator[](key).value = value;2947 lace(key);2948 }2949 2950 /// \brief Const subscript operator of the map.2951 ///2952 /// Const subscript operator of the map.2953 const Value& operator[](const Key& key) const {2954 return Parent::operator[](key).value;2955 }2956 2957 /// \brief Subscript operator of the map.2958 ///2959 /// Subscript operator of the map.2960 Reference operator[](const Key& key) {2961 return Reference(*this, key);2962 }2963 2964 /// \brief Iterator for the keys with the same value.2965 ///2966 /// Iterator for the keys with the same value. It works2967 /// like a graph item iterator, it can be converted to2968 /// the item type of the map, incremented with \c ++ operator, and2969 /// if the iterator leaves the last valid item, it will be equal to2970 /// \c INVALID.2971 class ItemIt : public Key {2972 public:2973 typedef Key Parent;2974 2975 /// \brief Invalid constructor \& conversion.2976 ///2977 /// This constructor initializes the iterator to be invalid.2978 /// \sa Invalid for more details.2979 ItemIt(Invalid) : Parent(INVALID), _map(0) {}2980 2981 /// \brief Creates an iterator with a value.2982 ///2983 /// Creates an iterator with a value. It iterates on the2984 /// keys mapped to the given value.2985 /// \param map The IterableIntMap.2986 /// \param value The value.2987 ItemIt(const IterableIntMap& map, int value) : _map(&map) {2988 if (value < 0 || value >= int(_map->_first.size())) {2989 Parent::operator=(INVALID);2990 } else {2991 Parent::operator=(_map->_first[value]);2992 }2993 }2994 2995 /// \brief Increment operator.2996 ///2997 /// Increment operator.2998 ItemIt& operator++() {2999 Parent::operator=(_map->IterableIntMap::Parent::3000 operator[](static_cast<Parent&>(*this)).next);3001 return *this;3002 }3003 3004 private:3005 const IterableIntMap* _map;3006 };3007 3008 protected:3009 3010 virtual void erase(const Key& key) {3011 unlace(key);3012 Parent::erase(key);3013 }3014 3015 virtual void erase(const std::vector<Key>& keys) {3016 for (int i = 0; i < int(keys.size()); ++i) {3017 unlace(keys[i]);3018 }3019 Parent::erase(keys);3020 }3021 3022 virtual void clear() {3023 _first.clear();3024 Parent::clear();3025 }3026 3027 private:3028 std::vector<Key> _first;3029 };3030 3031 namespace _maps_bits {3032 template <typename Item, typename Value>3033 struct IterableValueMapNode {3034 IterableValueMapNode(Value _value = Value()) : value(_value) {}3035 Item prev, next;3036 Value value;3037 };3038 }3039 3040 /// \brief Dynamic iterable map for comparable values.3041 ///3042 /// This class provides a special graph map type which can store a3043 /// comparable value for graph items (\c Node, \c Arc or \c Edge).3044 /// For each value it is possible to iterate on the keys mapped to3045 /// the value (\c ItemIt), and the values of the map can be accessed3046 /// with an STL compatible forward iterator (\c ValueIt).3047 /// The map stores a linked list for each value, which contains3048 /// the items mapped to the value, and the used values are stored3049 /// in balanced binary tree (\c std::map).3050 ///3051 /// \ref IterableBoolMap and \ref IterableIntMap are similar classes3052 /// specialized for \c bool and \c int values, respectively.3053 ///3054 /// This type is not reference map, so it cannot be modified with3055 /// the subscript operator.3056 ///3057 /// \tparam GR The graph type.3058 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or3059 /// \c GR::Edge).3060 /// \tparam V The value type of the map. It can be any comparable3061 /// value type.3062 ///3063 /// \see IterableBoolMap, IterableIntMap3064 /// \see CrossRefMap3065 template <typename GR, typename K, typename V>3066 class IterableValueMap3067 : protected ItemSetTraits<GR, K>::3068 template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {3069 public:3070 typedef typename ItemSetTraits<GR, K>::3071 template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;3072 3073 /// The key type3074 typedef K Key;3075 /// The value type3076 typedef V Value;3077 /// The graph type3078 typedef GR Graph;3079 3080 public:3081 3082 /// \brief Constructor of the map with a given value.3083 ///3084 /// Constructor of the map with a given value.3085 explicit IterableValueMap(const Graph& graph,3086 const Value& value = Value())3087 : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {3088 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {3089 lace(it);3090 }3091 }3092 3093 protected:3094 3095 void unlace(const Key& key) {3096 typename Parent::Value& node = Parent::operator[](key);3097 if (node.prev != INVALID) {3098 Parent::operator[](node.prev).next = node.next;3099 } else {3100 if (node.next != INVALID) {3101 _first[node.value] = node.next;3102 } else {3103 _first.erase(node.value);3104 }3105 }3106 if (node.next != INVALID) {3107 Parent::operator[](node.next).prev = node.prev;3108 }3109 }3110 3111 void lace(const Key& key) {3112 typename Parent::Value& node = Parent::operator[](key);3113 typename std::map<Value, Key>::iterator it = _first.find(node.value);3114 if (it == _first.end()) {3115 node.prev = node.next = INVALID;3116 _first.insert(std::make_pair(node.value, key));3117 } else {3118 node.prev = INVALID;3119 node.next = it->second;3120 if (node.next != INVALID) {3121 Parent::operator[](node.next).prev = key;3122 }3123 it->second = key;3124 }3125 }3126 3127 public:3128 3129 /// \brief Forward iterator for values.3130 ///3131 /// This iterator is an STL compatible forward3132 /// iterator on the values of the map. The values can3133 /// be accessed in the <tt>[beginValue, endValue)</tt> range.3134 class ValueIt3135 : public std::iterator<std::forward_iterator_tag, Value> {3136 friend class IterableValueMap;3137 private:3138 ValueIt(typename std::map<Value, Key>::const_iterator _it)3139 : it(_it) {}3140 public:3141 3142 /// Constructor3143 ValueIt() {}3144 3145 /// \e3146 ValueIt& operator++() { ++it; return *this; }3147 /// \e3148 ValueIt operator++(int) {3149 ValueIt tmp(*this);3150 operator++();3151 return tmp;3152 }3153 3154 /// \e3155 const Value& operator*() const { return it->first; }3156 /// \e3157 const Value* operator->() const { return &(it->first); }3158 3159 /// \e3160 bool operator==(ValueIt jt) const { return it == jt.it; }3161 /// \e3162 bool operator!=(ValueIt jt) const { return it != jt.it; }3163 3164 private:3165 typename std::map<Value, Key>::const_iterator it;3166 };3167 3168 /// \brief Returns an iterator to the first value.3169 ///3170 /// Returns an STL compatible iterator to the3171 /// first value of the map. The values of the3172 /// map can be accessed in the <tt>[beginValue, endValue)</tt>3173 /// range.3174 ValueIt beginValue() const {3175 return ValueIt(_first.begin());3176 }3177 3178 /// \brief Returns an iterator after the last value.3179 ///3180 /// Returns an STL compatible iterator after the3181 /// last value of the map. The values of the3182 /// map can be accessed in the <tt>[beginValue, endValue)</tt>3183 /// range.3184 ValueIt endValue() const {3185 return ValueIt(_first.end());3186 }3187 3188 /// \brief Set operation of the map.3189 ///3190 /// Set operation of the map.3191 void set(const Key& key, const Value& value) {3192 unlace(key);3193 Parent::operator[](key).value = value;3194 lace(key);3195 }3196 3197 /// \brief Const subscript operator of the map.3198 ///3199 /// Const subscript operator of the map.3200 const Value& operator[](const Key& key) const {3201 return Parent::operator[](key).value;3202 }3203 3204 /// \brief Iterator for the keys with the same value.3205 ///3206 /// Iterator for the keys with the same value. It works3207 /// like a graph item iterator, it can be converted to3208 /// the item type of the map, incremented with \c ++ operator, and3209 /// if the iterator leaves the last valid item, it will be equal to3210 /// \c INVALID.3211 class ItemIt : public Key {3212 public:3213 typedef Key Parent;3214 3215 /// \brief Invalid constructor \& conversion.3216 ///3217 /// This constructor initializes the iterator to be invalid.3218 /// \sa Invalid for more details.3219 ItemIt(Invalid) : Parent(INVALID), _map(0) {}3220 3221 /// \brief Creates an iterator with a value.3222 ///3223 /// Creates an iterator with a value. It iterates on the3224 /// keys which have the given value.3225 /// \param map The IterableValueMap3226 /// \param value The value3227 ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {3228 typename std::map<Value, Key>::const_iterator it =3229 map._first.find(value);3230 if (it == map._first.end()) {3231 Parent::operator=(INVALID);3232 } else {3233 Parent::operator=(it->second);3234 }3235 }3236 3237 /// \brief Increment operator.3238 ///3239 /// Increment Operator.3240 ItemIt& operator++() {3241 Parent::operator=(_map->IterableValueMap::Parent::3242 operator[](static_cast<Parent&>(*this)).next);3243 return *this;3244 }3245 3246 3247 private:3248 const IterableValueMap* _map;3249 };3250 3251 protected:3252 3253 virtual void add(const Key& key) {3254 Parent::add(key);3255 unlace(key);3256 }3257 3258 virtual void add(const std::vector<Key>& keys) {3259 Parent::add(keys);3260 for (int i = 0; i < int(keys.size()); ++i) {3261 lace(keys[i]);3262 }3263 }3264 3265 virtual void erase(const Key& key) {3266 unlace(key);3267 Parent::erase(key);3268 }3269 3270 virtual void erase(const std::vector<Key>& keys) {3271 for (int i = 0; i < int(keys.size()); ++i) {3272 unlace(keys[i]);3273 }3274 Parent::erase(keys);3275 }3276 3277 virtual void build() {3278 Parent::build();3279 for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {3280 lace(it);3281 }3282 }3283 3284 virtual void clear() {3285 _first.clear();3286 Parent::clear();3287 }3288 3289 private:3290 std::map<Value, Key> _first;3291 2331 }; 3292 2332 … … 3301 2341 public: 3302 2342 3303 /// The key type (the \c Arc type of the digraph).2343 ///\e 3304 2344 typedef typename GR::Arc Key; 3305 /// The value type (the \c Node type of the digraph).2345 ///\e 3306 2346 typedef typename GR::Node Value; 3307 2347 … … 3342 2382 public: 3343 2383 3344 /// The key type (the \c Arc type of the digraph).2384 ///\e 3345 2385 typedef typename GR::Arc Key; 3346 /// The value type (the \c Node type of the digraph).2386 ///\e 3347 2387 typedef typename GR::Node Value; 3348 2388 … … 3384 2424 public: 3385 2425 3386 /// The key type (the \c Edge type of the digraph).2426 typedef typename GR::Arc Value; 3387 2427 typedef typename GR::Edge Key; 3388 /// The value type (the \c Arc type of the digraph).3389 typedef typename GR::Arc Value;3390 2428 3391 2429 /// \brief Constructor … … 3426 2464 public: 3427 2465 3428 /// The key type (the \c Edge type of the digraph).2466 typedef typename GR::Arc Value; 3429 2467 typedef typename GR::Edge Key; 3430 /// The value type (the \c Arc type of the digraph).3431 typedef typename GR::Arc Value;3432 2468 3433 2469 /// \brief Constructor … … 3464 2500 /// whenever the digraph changes. 3465 2501 /// 3466 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 2502 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 3467 2503 /// may provide alternative ways to modify the digraph. 3468 2504 /// The correct behavior of InDegMap is not guarantied if these additional … … 3480 2516 3481 2517 public: 3482 2518 3483 2519 /// The graph type of InDegMap 3484 2520 typedef GR Graph; … … 3594 2630 /// whenever the digraph changes. 3595 2631 /// 3596 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 2632 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 3597 2633 /// may provide alternative ways to modify the digraph. 3598 2634 /// The correct behavior of OutDegMap is not guarantied if these additional -
lemon/min_cost_arborescence.h
r760 r672 489 489 /// The simplest way to execute the algorithm is to use 490 490 /// one of the member functions called \c run(...). \n 491 /// If you need bettercontrol on the execution,492 /// you have to call \ref init() first, then you can add several491 /// If you need more control on the execution, 492 /// first you must call \ref init(), then you can add several 493 493 /// source nodes with \ref addSource(). 494 494 /// Finally \ref start() will perform the arborescence -
lemon/network_simplex.h
r802 r710 41 41 /// 42 42 /// \ref NetworkSimplex implements the primal Network Simplex algorithm 43 /// for finding a \ref min_cost_flow "minimum cost flow" 44 /// \ref amo93networkflows, \ref dantzig63linearprog, 45 /// \ref kellyoneill91netsimplex. 43 /// for finding a \ref min_cost_flow "minimum cost flow". 46 44 /// This algorithm is a specialized version of the linear programming 47 45 /// simplex method directly for the minimum cost flow problem. … … 164 162 TEMPLATE_DIGRAPH_TYPEDEFS(GR); 165 163 164 typedef std::vector<Arc> ArcVector; 165 typedef std::vector<Node> NodeVector; 166 166 typedef std::vector<int> IntVector; 167 167 typedef std::vector<bool> BoolVector; … … 365 365 Cost c, min = 0; 366 366 int cnt = _block_size; 367 int e ;367 int e, min_arc = _next_arc; 368 368 for (e = _next_arc; e < _search_arc_num; ++e) { 369 369 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 370 370 if (c < min) { 371 371 min = c; 372 _in_arc = e;372 min_arc = e; 373 373 } 374 374 if (--cnt == 0) { 375 if (min < 0) goto search_end;375 if (min < 0) break; 376 376 cnt = _block_size; 377 377 } 378 378 } 379 for (e = 0; e < _next_arc; ++e) { 380 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 381 if (c < min) { 382 min = c; 383 _in_arc = e; 384 } 385 if (--cnt == 0) { 386 if (min < 0) goto search_end; 387 cnt = _block_size; 379 if (min == 0 || cnt > 0) { 380 for (e = 0; e < _next_arc; ++e) { 381 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 382 if (c < min) { 383 min = c; 384 min_arc = e; 385 } 386 if (--cnt == 0) { 387 if (min < 0) break; 388 cnt = _block_size; 389 } 388 390 } 389 391 } 390 392 if (min >= 0) return false; 391 392 search_end: 393 _in_arc = min_arc; 393 394 _next_arc = e; 394 395 return true; … … 428 429 { 429 430 // The main parameters of the pivot rule 430 const double LIST_LENGTH_FACTOR = 0.25;431 const double LIST_LENGTH_FACTOR = 1.0; 431 432 const int MIN_LIST_LENGTH = 10; 432 433 const double MINOR_LIMIT_FACTOR = 0.1; … … 445 446 bool findEnteringArc() { 446 447 Cost min, c; 447 int e ;448 int e, min_arc = _next_arc; 448 449 if (_curr_length > 0 && _minor_count < _minor_limit) { 449 450 // Minor iteration: select the best eligible arc from the … … 456 457 if (c < min) { 457 458 min = c; 458 _in_arc = e;459 min_arc = e; 459 460 } 460 elseif (c >= 0) {461 if (c >= 0) { 461 462 _candidates[i--] = _candidates[--_curr_length]; 462 463 } 463 464 } 464 if (min < 0) return true; 465 if (min < 0) { 466 _in_arc = min_arc; 467 return true; 468 } 465 469 } 466 470 … … 474 478 if (c < min) { 475 479 min = c; 476 _in_arc = e;480 min_arc = e; 477 481 } 478 if (_curr_length == _list_length) goto search_end; 479 } 480 } 481 for (e = 0; e < _next_arc; ++e) { 482 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 483 if (c < 0) { 484 _candidates[_curr_length++] = e; 485 if (c < min) { 486 min = c; 487 _in_arc = e; 482 if (_curr_length == _list_length) break; 483 } 484 } 485 if (_curr_length < _list_length) { 486 for (e = 0; e < _next_arc; ++e) { 487 c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 488 if (c < 0) { 489 _candidates[_curr_length++] = e; 490 if (c < min) { 491 min = c; 492 min_arc = e; 493 } 494 if (_curr_length == _list_length) break; 488 495 } 489 if (_curr_length == _list_length) goto search_end;490 496 } 491 497 } 492 498 if (_curr_length == 0) return false; 493 494 search_end:495 499 _minor_count = 1; 500 _in_arc = min_arc; 496 501 _next_arc = e; 497 502 return true; … … 545 550 { 546 551 // The main parameters of the pivot rule 547 const double BLOCK_SIZE_FACTOR = 1. 0;552 const double BLOCK_SIZE_FACTOR = 1.5; 548 553 const int MIN_BLOCK_SIZE = 10; 549 554 const double HEAD_LENGTH_FACTOR = 0.1; … … 574 579 // Extend the list 575 580 int cnt = _block_size; 581 int last_arc = 0; 576 582 int limit = _head_length; 577 583 578 for ( e = _next_arc; e < _search_arc_num; ++e) {584 for (int e = _next_arc; e < _search_arc_num; ++e) { 579 585 _cand_cost[e] = _state[e] * 580 586 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 581 587 if (_cand_cost[e] < 0) { 582 588 _candidates[_curr_length++] = e; 589 last_arc = e; 583 590 } 584 591 if (--cnt == 0) { 585 if (_curr_length > limit) goto search_end;592 if (_curr_length > limit) break; 586 593 limit = 0; 587 594 cnt = _block_size; 588 595 } 589 596 } 590 for (e = 0; e < _next_arc; ++e) { 591 _cand_cost[e] = _state[e] * 592 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 593 if (_cand_cost[e] < 0) { 594 _candidates[_curr_length++] = e; 595 } 596 if (--cnt == 0) { 597 if (_curr_length > limit) goto search_end; 598 limit = 0; 599 cnt = _block_size; 597 if (_curr_length <= limit) { 598 for (int e = 0; e < _next_arc; ++e) { 599 _cand_cost[e] = _state[e] * 600 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 601 if (_cand_cost[e] < 0) { 602 _candidates[_curr_length++] = e; 603 last_arc = e; 604 } 605 if (--cnt == 0) { 606 if (_curr_length > limit) break; 607 limit = 0; 608 cnt = _block_size; 609 } 600 610 } 601 611 } 602 612 if (_curr_length == 0) return false; 603 604 search_end: 613 _next_arc = last_arc + 1; 605 614 606 615 // Make heap of the candidate list (approximating a partial sort) … … 610 619 // Pop the first element of the heap 611 620 _in_arc = _candidates[0]; 612 _next_arc = e;613 621 pop_heap( _candidates.begin(), _candidates.begin() + _curr_length, 614 622 _sort_func ); … … 626 634 /// 627 635 /// \param graph The digraph the algorithm runs on. 628 /// \param arc_mixing Indicate if the arcs have to be stored in a 629 /// mixed order in the internal data structure. 630 /// In special cases, it could lead to better overall performance, 631 /// but it is usually slower. Therefore it is disabled by default. 632 NetworkSimplex(const GR& graph, bool arc_mixing = false) : 636 NetworkSimplex(const GR& graph) : 633 637 _graph(graph), _node_id(graph), _arc_id(graph), 634 638 INF(std::numeric_limits<Value>::has_infinity ? … … 668 672 _state.resize(max_arc_num); 669 673 670 // Copy the graph 674 // Copy the graph (store the arcs in a mixed order) 671 675 int i = 0; 672 676 for (NodeIt n(_graph); n != INVALID; ++n, ++i) { 673 677 _node_id[n] = i; 674 678 } 675 if (arc_mixing) { 676 // Store the arcs in a mixed order 677 int k = std::max(int(std::sqrt(double(_arc_num))), 10); 678 int i = 0, j = 0; 679 for (ArcIt a(_graph); a != INVALID; ++a) { 680 _arc_id[a] = i; 681 _source[i] = _node_id[_graph.source(a)]; 682 _target[i] = _node_id[_graph.target(a)]; 683 if ((i += k) >= _arc_num) i = ++j; 684 } 685 } else { 686 // Store the arcs in the original order 687 int i = 0; 688 for (ArcIt a(_graph); a != INVALID; ++a, ++i) { 689 _arc_id[a] = i; 690 _source[i] = _node_id[_graph.source(a)]; 691 _target[i] = _node_id[_graph.target(a)]; 692 } 679 int k = std::max(int(std::sqrt(double(_arc_num))), 10); 680 i = 0; 681 for (ArcIt a(_graph); a != INVALID; ++a) { 682 _arc_id[a] = i; 683 _source[i] = _node_id[_graph.source(a)]; 684 _target[i] = _node_id[_graph.target(a)]; 685 if ((i += k) >= _arc_num) i = (i % k) + 1; 693 686 } 694 687 695 // Reset parameters 696 reset(); 688 // Initialize maps 689 for (int i = 0; i != _node_num; ++i) { 690 _supply[i] = 0; 691 } 692 for (int i = 0; i != _arc_num; ++i) { 693 _lower[i] = 0; 694 _upper[i] = INF; 695 _cost[i] = 1; 696 } 697 _have_lower = false; 698 _stype = GEQ; 697 699 } 698 700 … … 767 769 /// If neither this function nor \ref stSupply() is used before 768 770 /// calling \ref run(), the supply of each node will be set to zero. 771 /// (It makes sense only if non-zero lower bounds are given.) 769 772 /// 770 773 /// \param map A node map storing the supply values. … … 787 790 /// If neither this function nor \ref supplyMap() is used before 788 791 /// calling \ref run(), the supply of each node will be set to zero. 792 /// (It makes sense only if non-zero lower bounds are given.) 789 793 /// 790 794 /// Using this function has the same effect as using \ref supplyMap() -
lemon/path.h
r798 r606 1016 1016 /// \brief The source of a path 1017 1017 /// 1018 /// This function returns the source node of the given path. 1019 /// If the path is empty, then it returns \c INVALID. 1018 /// This function returns the source of the given path. 1020 1019 template <typename Digraph, typename Path> 1021 1020 typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) { 1022 return path.empty() ? INVALID :digraph.source(path.front());1021 return digraph.source(path.front()); 1023 1022 } 1024 1023 1025 1024 /// \brief The target of a path 1026 1025 /// 1027 /// This function returns the target node of the given path. 1028 /// If the path is empty, then it returns \c INVALID. 1026 /// This function returns the target of the given path. 1029 1027 template <typename Digraph, typename Path> 1030 1028 typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) { 1031 return path.empty() ? INVALID :digraph.target(path.back());1029 return digraph.target(path.back()); 1032 1030 } 1033 1031 -
lemon/preflow.h
r802 r688 53 53 /// The type of the map that stores the flow values. 54 54 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 55 #ifdef DOXYGEN56 typedef GR::ArcMap<Value> FlowMap;57 #else58 55 typedef typename Digraph::template ArcMap<Value> FlowMap; 59 #endif60 56 61 57 /// \brief Instantiates a FlowMap. … … 72 68 /// The elevator type used by Preflow algorithm. 73 69 /// 74 /// \sa Elevator, LinkedElevator 75 #ifdef DOXYGEN 76 typedef lemon::Elevator<GR, GR::Node> Elevator; 77 #else 78 typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator; 79 #endif 70 /// \sa Elevator 71 /// \sa LinkedElevator 72 typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator; 80 73 81 74 /// \brief Instantiates an Elevator. … … 103 96 /// This class provides an implementation of Goldberg-Tarjan's \e preflow 104 97 /// \e push-relabel algorithm producing a \ref max_flow 105 /// "flow of maximum value" in a digraph \ref clrs01algorithms, 106 /// \ref amo93networkflows, \ref goldberg88newapproach. 98 /// "flow of maximum value" in a digraph. 107 99 /// The preflow algorithms are the fastest known maximum 108 /// flow algorithms. The current implementation use sa mixture of the100 /// flow algorithms. The current implementation use a mixture of the 109 101 /// \e "highest label" and the \e "bound decrease" heuristics. 110 102 /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. … … 380 372 } 381 373 382 /// \brief Sets the tolerance used by the algorithm. 383 /// 384 /// Sets the tolerance object used by the algorithm. 385 /// \return <tt>(*this)</tt> 386 Preflow& tolerance(const Tolerance& tolerance) { 374 /// \brief Sets the tolerance used by algorithm. 375 /// 376 /// Sets the tolerance used by algorithm. 377 Preflow& tolerance(const Tolerance& tolerance) const { 387 378 _tolerance = tolerance; 388 379 return *this; … … 391 382 /// \brief Returns a const reference to the tolerance. 392 383 /// 393 /// Returns a const reference to the tolerance object used by 394 /// the algorithm. 384 /// Returns a const reference to the tolerance. 395 385 const Tolerance& tolerance() const { 396 return _tolerance;386 return tolerance; 397 387 } 398 388 … … 400 390 /// The simplest way to execute the preflow algorithm is to use 401 391 /// \ref run() or \ref runMinCut().\n 402 /// If you need bettercontrol on the initial solution or the execution,403 /// you have to call one of the \ref init() functions first, then392 /// If you need more control on the initial solution or the execution, 393 /// first you have to call one of the \ref init() functions, then 404 394 /// \ref startFirstPhase() and if you need it \ref startSecondPhase(). 405 395 -
lemon/radix_heap.h
r758 r730 20 20 #define LEMON_RADIX_HEAP_H 21 21 22 ///\ingroup heaps22 ///\ingroup auxdat 23 23 ///\file 24 ///\brief Radix heap implementation.24 ///\brief Radix Heap implementation. 25 25 26 26 #include <vector> … … 30 30 31 31 32 /// \ingroup heaps32 /// \ingroup auxdata 33 33 /// 34 /// \brief Radix heap data structure.34 /// \brief A Radix Heap implementation. 35 35 /// 36 /// This class implements the \e radix \e heap data structure. 37 /// It practically conforms to the \ref concepts::Heap "heap concept", 38 /// but it has some limitations due its special implementation. 39 /// The type of the priorities must be \c int and the priority of an 40 /// item cannot be decreased under the priority of the last removed item. 36 /// This class implements the \e radix \e heap data structure. A \e heap 37 /// is a data structure for storing items with specified values called \e 38 /// priorities in such a way that finding the item with minimum priority is 39 /// efficient. This heap type can store only items with \e int priority. 40 /// In a heap one can change the priority of an item, add or erase an 41 /// item, but the priority cannot be decreased under the last removed 42 /// item's priority. 41 43 /// 42 /// \tparam IM A read-writable item map with \c int values, used 43 /// internally to handle the cross references. 44 /// \param IM A read and writable Item int map, used internally 45 /// to handle the cross references. 46 /// 47 /// \see BinHeap 48 /// \see Dijkstra 44 49 template <typename IM> 45 50 class RadixHeap { 46 51 47 52 public: 48 49 /// Type of the item-int map.53 typedef typename IM::Key Item; 54 typedef int Prio; 50 55 typedef IM ItemIntMap; 51 /// Type of the priorities.52 typedef int Prio;53 /// Type of the items stored in the heap.54 typedef typename ItemIntMap::Key Item;55 56 56 57 /// \brief Exception thrown by RadixHeap. 57 58 /// 58 /// This exception is thrown when an item is inserted into a59 /// RadixHeap with a priority smaller than the last erased one.59 /// This Exception is thrown when a smaller priority 60 /// is inserted into the \e RadixHeap then the last time erased. 60 61 /// \see RadixHeap 61 class PriorityUnderflowError : public Exception { 62 63 class UnderFlowPriorityError : public Exception { 62 64 public: 63 65 virtual const char* what() const throw() { 64 return "lemon::RadixHeap:: PriorityUnderflowError";66 return "lemon::RadixHeap::UnderFlowPriorityError"; 65 67 } 66 68 }; 67 69 68 /// \brief Type to represent the states of the items.69 /// 70 /// Each item has a state associated to it. It canbe "in heap",71 /// "pre -heap" or "post-heap". The latter two are indifferent from the70 /// \brief Type to represent the items states. 71 /// 72 /// Each Item element have a state associated to it. It may be "in heap", 73 /// "pre heap" or "post heap". The latter two are indifferent from the 72 74 /// heap's point of view, but may be useful to the user. 73 75 /// 74 /// The item-int map must be initialized in such way that it assigns75 /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.76 /// The ItemIntMap \e should be initialized in such way that it maps 77 /// PRE_HEAP (-1) to any element to be put in the heap... 76 78 enum State { 77 IN_HEAP = 0, ///< = 0.78 PRE_HEAP = -1, ///< = -1.79 POST_HEAP = -2 ///< = -2.79 IN_HEAP = 0, 80 PRE_HEAP = -1, 81 POST_HEAP = -2 80 82 }; 81 83 … … 95 97 }; 96 98 97 std::vector<RadixItem> _data;98 std::vector<RadixBox> _boxes;99 std::vector<RadixItem> data; 100 std::vector<RadixBox> boxes; 99 101 100 102 ItemIntMap &_iim; 101 103 104 102 105 public: 103 104 /// \brief Constructor.105 /// 106 /// Constructor.107 /// \param map A map that assigns \c int values to the items.108 /// It is used internally to handle the cross references.109 /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.110 /// \param minimum The initial minimum value of the heap.111 /// \param capacity The initial capacityof the heap.112 RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)113 : _iim(map)114 {115 _boxes.push_back(RadixBox(minimum, 1));116 _boxes.push_back(RadixBox(minimum+ 1, 1));117 while (lower( _boxes.size() - 1, capacity + minimum- 1)) {106 /// \brief The constructor. 107 /// 108 /// The constructor. 109 /// 110 /// \param map It should be given to the constructor, since it is used 111 /// internally to handle the cross references. The value of the map 112 /// should be PRE_HEAP (-1) for each element. 113 /// 114 /// \param minimal The initial minimal value of the heap. 115 /// \param capacity It determines the initial capacity of the heap. 116 RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0) 117 : _iim(map) { 118 boxes.push_back(RadixBox(minimal, 1)); 119 boxes.push_back(RadixBox(minimal + 1, 1)); 120 while (lower(boxes.size() - 1, capacity + minimal - 1)) { 118 121 extend(); 119 122 } 120 123 } 121 124 122 /// \brief The number of items stored in the heap. 123 /// 124 /// This function returns the number of items stored in the heap. 125 int size() const { return _data.size(); } 126 127 /// \brief Check if the heap is empty. 128 /// 129 /// This function returns \c true if the heap is empty. 130 bool empty() const { return _data.empty(); } 131 132 /// \brief Make the heap empty. 133 /// 134 /// This functon makes the heap empty. 135 /// It does not change the cross reference map. If you want to reuse 136 /// a heap that is not surely empty, you should first clear it and 137 /// then you should set the cross reference map to \c PRE_HEAP 138 /// for each item. 139 /// \param minimum The minimum value of the heap. 140 /// \param capacity The capacity of the heap. 141 void clear(int minimum = 0, int capacity = 0) { 142 _data.clear(); _boxes.clear(); 143 _boxes.push_back(RadixBox(minimum, 1)); 144 _boxes.push_back(RadixBox(minimum + 1, 1)); 145 while (lower(_boxes.size() - 1, capacity + minimum - 1)) { 125 /// The number of items stored in the heap. 126 /// 127 /// \brief Returns the number of items stored in the heap. 128 int size() const { return data.size(); } 129 /// \brief Checks if the heap stores no items. 130 /// 131 /// Returns \c true if and only if the heap stores no items. 132 bool empty() const { return data.empty(); } 133 134 /// \brief Make empty this heap. 135 /// 136 /// Make empty this heap. It does not change the cross reference 137 /// map. If you want to reuse a heap what is not surely empty you 138 /// should first clear the heap and after that you should set the 139 /// cross reference map for each item to \c PRE_HEAP. 140 void clear(int minimal = 0, int capacity = 0) { 141 data.clear(); boxes.clear(); 142 boxes.push_back(RadixBox(minimal, 1)); 143 boxes.push_back(RadixBox(minimal + 1, 1)); 144 while (lower(boxes.size() - 1, capacity + minimal - 1)) { 146 145 extend(); 147 146 } … … 151 150 152 151 bool upper(int box, Prio pr) { 153 return pr < _boxes[box].min;152 return pr < boxes[box].min; 154 153 } 155 154 156 155 bool lower(int box, Prio pr) { 157 return pr >= _boxes[box].min + _boxes[box].size;158 } 159 160 // Remove item from the box list156 return pr >= boxes[box].min + boxes[box].size; 157 } 158 159 /// \brief Remove item from the box list. 161 160 void remove(int index) { 162 if ( _data[index].prev >= 0) {163 _data[_data[index].prev].next = _data[index].next;161 if (data[index].prev >= 0) { 162 data[data[index].prev].next = data[index].next; 164 163 } else { 165 _boxes[_data[index].box].first = _data[index].next;166 } 167 if ( _data[index].next >= 0) {168 _data[_data[index].next].prev = _data[index].prev;169 } 170 } 171 172 // Insert item into the box list164 boxes[data[index].box].first = data[index].next; 165 } 166 if (data[index].next >= 0) { 167 data[data[index].next].prev = data[index].prev; 168 } 169 } 170 171 /// \brief Insert item into the box list. 173 172 void insert(int box, int index) { 174 if ( _boxes[box].first == -1) {175 _boxes[box].first = index;176 _data[index].next = _data[index].prev = -1;173 if (boxes[box].first == -1) { 174 boxes[box].first = index; 175 data[index].next = data[index].prev = -1; 177 176 } else { 178 _data[index].next = _boxes[box].first;179 _data[_boxes[box].first].prev = index;180 _data[index].prev = -1;181 _boxes[box].first = index;182 } 183 _data[index].box = box;184 } 185 186 // Add a new box to the box list177 data[index].next = boxes[box].first; 178 data[boxes[box].first].prev = index; 179 data[index].prev = -1; 180 boxes[box].first = index; 181 } 182 data[index].box = box; 183 } 184 185 /// \brief Add a new box to the box list. 187 186 void extend() { 188 int min = _boxes.back().min + _boxes.back().size;189 int bs = 2 * _boxes.back().size;190 _boxes.push_back(RadixBox(min, bs));191 } 192 193 // Move an item up into the proper box.194 void bubble Up(int index) {195 if (!lower( _data[index].box, _data[index].prio)) return;187 int min = boxes.back().min + boxes.back().size; 188 int bs = 2 * boxes.back().size; 189 boxes.push_back(RadixBox(min, bs)); 190 } 191 192 /// \brief Move an item up into the proper box. 193 void bubble_up(int index) { 194 if (!lower(data[index].box, data[index].prio)) return; 196 195 remove(index); 197 int box = findUp( _data[index].box, _data[index].prio);196 int box = findUp(data[index].box, data[index].prio); 198 197 insert(box, index); 199 198 } 200 199 201 // Find up the proper box for the item with the given priority200 /// \brief Find up the proper box for the item with the given prio. 202 201 int findUp(int start, int pr) { 203 202 while (lower(start, pr)) { 204 if (++start == int( _boxes.size())) {203 if (++start == int(boxes.size())) { 205 204 extend(); 206 205 } … … 209 208 } 210 209 211 // Move an item down into the proper box212 void bubble Down(int index) {213 if (!upper( _data[index].box, _data[index].prio)) return;210 /// \brief Move an item down into the proper box. 211 void bubble_down(int index) { 212 if (!upper(data[index].box, data[index].prio)) return; 214 213 remove(index); 215 int box = findDown( _data[index].box, _data[index].prio);214 int box = findDown(data[index].box, data[index].prio); 216 215 insert(box, index); 217 216 } 218 217 219 // Find down the proper box for the item with the given priority218 /// \brief Find up the proper box for the item with the given prio. 220 219 int findDown(int start, int pr) { 221 220 while (upper(start, pr)) { 222 if (--start < 0) throw PriorityUnderflowError();221 if (--start < 0) throw UnderFlowPriorityError(); 223 222 } 224 223 return start; 225 224 } 226 225 227 // Find the first non-empty box226 /// \brief Find the first not empty box. 228 227 int findFirst() { 229 228 int first = 0; 230 while ( _boxes[first].first == -1) ++first;229 while (boxes[first].first == -1) ++first; 231 230 return first; 232 231 } 233 232 234 // Gives back the minimum priority of the given box233 /// \brief Gives back the minimal prio of the box. 235 234 int minValue(int box) { 236 int min = _data[_boxes[box].first].prio;237 for (int k = _boxes[box].first; k != -1; k = _data[k].next) {238 if ( _data[k].prio < min) min = _data[k].prio;235 int min = data[boxes[box].first].prio; 236 for (int k = boxes[box].first; k != -1; k = data[k].next) { 237 if (data[k].prio < min) min = data[k].prio; 239 238 } 240 239 return min; 241 240 } 242 241 243 // Rearrange the items of the heap and make the first box non-empty 242 /// \brief Rearrange the items of the heap and makes the 243 /// first box not empty. 244 244 void moveDown() { 245 245 int box = findFirst(); … … 247 247 int min = minValue(box); 248 248 for (int i = 0; i <= box; ++i) { 249 _boxes[i].min = min;250 min += _boxes[i].size;251 } 252 int curr = _boxes[box].first, next;249 boxes[i].min = min; 250 min += boxes[i].size; 251 } 252 int curr = boxes[box].first, next; 253 253 while (curr != -1) { 254 next = _data[curr].next;255 bubble Down(curr);254 next = data[curr].next; 255 bubble_down(curr); 256 256 curr = next; 257 257 } 258 258 } 259 259 260 void relocate Last(int index) {261 if (index != int( _data.size()) - 1) {262 _data[index] = _data.back();263 if ( _data[index].prev != -1) {264 _data[_data[index].prev].next = index;260 void relocate_last(int index) { 261 if (index != int(data.size()) - 1) { 262 data[index] = data.back(); 263 if (data[index].prev != -1) { 264 data[data[index].prev].next = index; 265 265 } else { 266 _boxes[_data[index].box].first = index;266 boxes[data[index].box].first = index; 267 267 } 268 if ( _data[index].next != -1) {269 _data[_data[index].next].prev = index;268 if (data[index].next != -1) { 269 data[data[index].next].prev = index; 270 270 } 271 _iim[ _data[index].item] = index;272 } 273 _data.pop_back();271 _iim[data[index].item] = index; 272 } 273 data.pop_back(); 274 274 } 275 275 … … 278 278 /// \brief Insert an item into the heap with the given priority. 279 279 /// 280 /// This function inserts the given item into the heap with the 281 /// given priority. 280 /// Adds \c i to the heap with priority \c p. 282 281 /// \param i The item to insert. 283 282 /// \param p The priority of the item. 284 /// \pre \e i must not be stored in the heap.285 /// \warning This method may throw an \c UnderFlowPriorityException.286 283 void push(const Item &i, const Prio &p) { 287 int n = _data.size();284 int n = data.size(); 288 285 _iim.set(i, n); 289 _data.push_back(RadixItem(i, p));290 while (lower( _boxes.size() - 1, p)) {286 data.push_back(RadixItem(i, p)); 287 while (lower(boxes.size() - 1, p)) { 291 288 extend(); 292 289 } 293 int box = findDown( _boxes.size() - 1, p);290 int box = findDown(boxes.size() - 1, p); 294 291 insert(box, n); 295 292 } 296 293 297 /// \brief Return the item havingminimum priority.298 /// 299 /// This function returns the item havingminimum priority.300 /// \pre The heap must be non -empty.294 /// \brief Returns the item with minimum priority. 295 /// 296 /// This method returns the item with minimum priority. 297 /// \pre The heap must be nonempty. 301 298 Item top() const { 302 299 const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown(); 303 return _data[_boxes[0].first].item;304 } 305 306 /// \brief The minimum priority.307 /// 308 /// This functionreturns the minimum priority.309 /// \pre The heap must be non -empty.300 return data[boxes[0].first].item; 301 } 302 303 /// \brief Returns the minimum priority. 304 /// 305 /// It returns the minimum priority. 306 /// \pre The heap must be nonempty. 310 307 Prio prio() const { 311 308 const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown(); 312 return _data[_boxes[0].first].prio;309 return data[boxes[0].first].prio; 313 310 } 314 311 315 /// \brief Remove the item havingminimum priority.316 /// 317 /// This function removes the item havingminimum priority.312 /// \brief Deletes the item with minimum priority. 313 /// 314 /// This method deletes the item with minimum priority. 318 315 /// \pre The heap must be non-empty. 319 316 void pop() { 320 317 moveDown(); 321 int index = _boxes[0].first;322 _iim[ _data[index].item] = POST_HEAP;318 int index = boxes[0].first; 319 _iim[data[index].item] = POST_HEAP; 323 320 remove(index); 324 relocateLast(index); 325 } 326 327 /// \brief Remove the given item from the heap. 328 /// 329 /// This function removes the given item from the heap if it is 330 /// already stored. 331 /// \param i The item to delete. 332 /// \pre \e i must be in the heap. 321 relocate_last(index); 322 } 323 324 /// \brief Deletes \c i from the heap. 325 /// 326 /// This method deletes item \c i from the heap, if \c i was 327 /// already stored in the heap. 328 /// \param i The item to erase. 333 329 void erase(const Item &i) { 334 330 int index = _iim[i]; 335 331 _iim[i] = POST_HEAP; 336 332 remove(index); 337 relocate Last(index);333 relocate_last(index); 338 334 } 339 335 340 /// \brief The priority of the given item.341 /// 342 /// This function returns the priority of the given item.343 /// \p aram i The item.344 /// \p re \e i must be in the heap.336 /// \brief Returns the priority of \c i. 337 /// 338 /// This function returns the priority of item \c i. 339 /// \pre \c i must be in the heap. 340 /// \param i The item. 345 341 Prio operator[](const Item &i) const { 346 342 int idx = _iim[i]; 347 return _data[idx].prio;348 } 349 350 /// \brief Set the priority of an item or insert it, if it is351 /// not stored in the heap.352 /// 353 /// This method sets the priority of the given item if it is354 /// already stored in the heap. Otherwise it inserts the given355 /// item into the heap with the given priority.343 return data[idx].prio; 344 } 345 346 /// \brief \c i gets to the heap with priority \c p independently 347 /// if \c i was already there. 348 /// 349 /// This method calls \ref push(\c i, \c p) if \c i is not stored 350 /// in the heap and sets the priority of \c i to \c p otherwise. 351 /// It may throw an \e UnderFlowPriorityException. 356 352 /// \param i The item. 357 353 /// \param p The priority. 358 /// \pre \e i must be in the heap.359 /// \warning This method may throw an \c UnderFlowPriorityException.360 354 void set(const Item &i, const Prio &p) { 361 355 int idx = _iim[i]; … … 363 357 push(i, p); 364 358 } 365 else if( p >= _data[idx].prio ) {366 _data[idx].prio = p;367 bubble Up(idx);359 else if( p >= data[idx].prio ) { 360 data[idx].prio = p; 361 bubble_up(idx); 368 362 } else { 369 _data[idx].prio = p; 370 bubbleDown(idx); 371 } 372 } 373 374 /// \brief Decrease the priority of an item to the given value. 375 /// 376 /// This function decreases the priority of an item to the given value. 363 data[idx].prio = p; 364 bubble_down(idx); 365 } 366 } 367 368 369 /// \brief Decreases the priority of \c i to \c p. 370 /// 371 /// This method decreases the priority of item \c i to \c p. 372 /// \pre \c i must be stored in the heap with priority at least \c p, and 373 /// \c should be greater or equal to the last removed item's priority. 377 374 /// \param i The item. 378 375 /// \param p The priority. 379 /// \pre \e i must be stored in the heap with priority at least \e p.380 /// \warning This method may throw an \c UnderFlowPriorityException.381 376 void decrease(const Item &i, const Prio &p) { 382 377 int idx = _iim[i]; 383 _data[idx].prio = p; 384 bubbleDown(idx); 385 } 386 387 /// \brief Increase the priority of an item to the given value. 388 /// 389 /// This function increases the priority of an item to the given value. 378 data[idx].prio = p; 379 bubble_down(idx); 380 } 381 382 /// \brief Increases the priority of \c i to \c p. 383 /// 384 /// This method sets the priority of item \c i to \c p. 385 /// \pre \c i must be stored in the heap with priority at most \c p 390 386 /// \param i The item. 391 387 /// \param p The priority. 392 /// \pre \e i must be stored in the heap with priority at most \e p.393 388 void increase(const Item &i, const Prio &p) { 394 389 int idx = _iim[i]; 395 _data[idx].prio = p;396 bubble Up(idx);397 } 398 399 /// \brief Return the state of an item.400 /// 401 /// This method returns \c PRE_HEAP if the given item has never402 /// been in the heap, \c IN_HEAP if it is in the heap at the moment,403 /// and \c POST_HEAP otherwise.404 /// In the latter case it is possible that the item will get back405 /// to the heap again.390 data[idx].prio = p; 391 bubble_up(idx); 392 } 393 394 /// \brief Returns if \c item is in, has already been in, or has 395 /// never been in the heap. 396 /// 397 /// This method returns PRE_HEAP if \c item has never been in the 398 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP 399 /// otherwise. In the latter case it is possible that \c item will 400 /// get back to the heap again. 406 401 /// \param i The item. 407 402 State state(const Item &i) const { … … 411 406 } 412 407 413 /// \brief Set the state of anitem in the heap.414 /// 415 /// This function sets the state of the given item in the heap.416 /// It can be used to manually clear the heap when it is important417 /// to achivebetter time complexity.408 /// \brief Sets the state of the \c item in the heap. 409 /// 410 /// Sets the state of the \c item in the heap. It can be used to 411 /// manually clear the heap when it is important to achive the 412 /// better time complexity. 418 413 /// \param i The item. 419 414 /// \param st The state. It should not be \c IN_HEAP. -
lemon/smart_graph.h
r827 r825 33 33 34 34 class SmartDigraph; 35 35 ///Base of SmartDigraph 36 37 ///Base of SmartDigraph 38 /// 36 39 class SmartDigraphBase { 37 40 protected: … … 185 188 ///\brief A smart directed graph class. 186 189 /// 187 ///\ref SmartDigraph is a simple and fast digraph implementation. 188 ///It is also quite memory efficient but at the price 189 ///that it does not support node and arc deletion 190 ///(except for the Snapshot feature). 190 ///This is a simple and fast digraph implementation. 191 ///It is also quite memory efficient, but at the price 192 ///that <b> it does support only limited (only stack-like) 193 ///node and arc deletions</b>. 194 ///It fully conforms to the \ref concepts::Digraph "Digraph concept". 191 195 /// 192 ///This type fully conforms to the \ref concepts::Digraph "Digraph concept" 193 ///and it also provides some additional functionalities. 194 ///Most of its member functions and nested classes are documented 195 ///only in the concept class. 196 /// 197 ///\sa concepts::Digraph 198 ///\sa SmartGraph 196 ///\sa concepts::Digraph. 199 197 class SmartDigraph : public ExtendedSmartDigraphBase { 200 198 typedef ExtendedSmartDigraphBase Parent; 201 199 202 200 private: 203 /// Digraphs are \e not copy constructible. Use DigraphCopy instead. 201 202 ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. 203 204 ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. 205 /// 204 206 SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {}; 205 /// \brief Assignment of a digraph to another one is \e not allowed. 206 /// Use DigraphCopy instead. 207 ///\brief Assignment of SmartDigraph to another one is \e not allowed. 208 ///Use DigraphCopy() instead. 209 210 ///Assignment of SmartDigraph to another one is \e not allowed. 211 ///Use DigraphCopy() instead. 207 212 void operator=(const SmartDigraph &) {} 208 213 … … 217 222 ///Add a new node to the digraph. 218 223 219 /// This function addsa new node to the digraph.220 /// \return The new node.224 /// Add a new node to the digraph. 225 /// \return The new node. 221 226 Node addNode() { return Parent::addNode(); } 222 227 223 228 ///Add a new arc to the digraph. 224 229 225 /// This function addsa new arc to the digraph with source node \c s230 ///Add a new arc to the digraph with source node \c s 226 231 ///and target node \c t. 227 232 ///\return The new arc. 228 Arc addArc( Node s, Nodet) {233 Arc addArc(const Node& s, const Node& t) { 229 234 return Parent::addArc(s, t); 230 235 } 231 236 237 /// \brief Using this it is possible to avoid the superfluous memory 238 /// allocation. 239 240 /// Using this it is possible to avoid the superfluous memory 241 /// allocation: if you know that the digraph you want to build will 242 /// be very large (e.g. it will contain millions of nodes and/or arcs) 243 /// then it is worth reserving space for this amount before starting 244 /// to build the digraph. 245 /// \sa reserveArc 246 void reserveNode(int n) { nodes.reserve(n); }; 247 248 /// \brief Using this it is possible to avoid the superfluous memory 249 /// allocation. 250 251 /// Using this it is possible to avoid the superfluous memory 252 /// allocation: if you know that the digraph you want to build will 253 /// be very large (e.g. it will contain millions of nodes and/or arcs) 254 /// then it is worth reserving space for this amount before starting 255 /// to build the digraph. 256 /// \sa reserveNode 257 void reserveArc(int m) { arcs.reserve(m); }; 258 232 259 /// \brief Node validity check 233 260 /// 234 /// This function gives back \ctrue if the given node is valid,235 /// i .e. it is a real node of the digraph.261 /// This function gives back true if the given node is valid, 262 /// ie. it is a real node of the graph. 236 263 /// 237 264 /// \warning A removed node (using Snapshot) could become valid again 238 /// if new nodes are added to the digraph.265 /// when new nodes are added to the graph. 239 266 bool valid(Node n) const { return Parent::valid(n); } 240 267 241 268 /// \brief Arc validity check 242 269 /// 243 /// This function gives back \ctrue if the given arc is valid,244 /// i .e. it is a real arc of the digraph.270 /// This function gives back true if the given arc is valid, 271 /// ie. it is a real arc of the graph. 245 272 /// 246 273 /// \warning A removed arc (using Snapshot) could become valid again 247 /// ifnew arcs are added to the graph.274 /// when new arcs are added to the graph. 248 275 bool valid(Arc a) const { return Parent::valid(a); } 249 276 277 ///Clear the digraph. 278 279 ///Erase all the nodes and arcs from the digraph. 280 /// 281 void clear() { 282 Parent::clear(); 283 } 284 250 285 ///Split a node. 251 286 252 ///This function splits the given node. First, a new node is added 253 ///to the digraph, then the source of each outgoing arc of node \c n 254 ///is moved to this new node. 255 ///If the second parameter \c connect is \c true (this is the default 256 ///value), then a new arc from node \c n to the newly created node 257 ///is also added. 287 ///This function splits a node. First a new node is added to the digraph, 288 ///then the source of each outgoing arc of \c n is moved to this new node. 289 ///If \c connect is \c true (this is the default value), then a new arc 290 ///from \c n to the newly created node is also added. 258 291 ///\return The newly created node. 259 292 /// 260 ///\note All iterators remain valid. 261 /// 293 ///\note The <tt>Arc</tt>s 294 ///referencing a moved arc remain 295 ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s 296 ///may be invalidated. 262 297 ///\warning This functionality cannot be used together with the Snapshot 263 298 ///feature. … … 274 309 } 275 310 276 ///Clear the digraph.277 278 ///This function erases all nodes and arcs from the digraph.279 ///280 void clear() {281 Parent::clear();282 }283 284 /// Reserve memory for nodes.285 286 /// Using this function, it is possible to avoid superfluous memory287 /// allocation: if you know that the digraph you want to build will288 /// be large (e.g. it will contain millions of nodes and/or arcs),289 /// then it is worth reserving space for this amount before starting290 /// to build the digraph.291 /// \sa reserveArc()292 void reserveNode(int n) { nodes.reserve(n); };293 294 /// Reserve memory for arcs.295 296 /// Using this function, it is possible to avoid superfluous memory297 /// allocation: if you know that the digraph you want to build will298 /// be large (e.g. it will contain millions of nodes and/or arcs),299 /// then it is worth reserving space for this amount before starting300 /// to build the digraph.301 /// \sa reserveNode()302 void reserveArc(int m) { arcs.reserve(m); };303 304 311 public: 305 312 … … 326 333 public: 327 334 328 ///Class to make a snapshot of the digraph and to rest oreit later.329 330 ///Class to make a snapshot of the digraph and to rest oreit later.335 ///Class to make a snapshot of the digraph and to restrore to it later. 336 337 ///Class to make a snapshot of the digraph and to restrore to it later. 331 338 /// 332 339 ///The newly added nodes and arcs can be removed using the 333 ///restore() function. This is the only way for deleting nodes and/or 334 ///arcs from a SmartDigraph structure. 335 /// 336 ///\note After a state is restored, you cannot restore a later state, 337 ///i.e. you cannot add the removed nodes and arcs again using 338 ///another Snapshot instance. 339 /// 340 ///\warning Node splitting cannot be restored. 341 ///\warning The validity of the snapshot is not stored due to 342 ///performance reasons. If you do not use the snapshot correctly, 343 ///it can cause broken program, invalid or not restored state of 344 ///the digraph or no change. 340 ///restore() function. 341 ///\note After you restore a state, you cannot restore 342 ///a later state, in other word you cannot add again the arcs deleted 343 ///by restore() using another one Snapshot instance. 344 /// 345 ///\warning If you do not use correctly the snapshot that can cause 346 ///either broken program, invalid state of the digraph, valid but 347 ///not the restored digraph or no change. Because the runtime performance 348 ///the validity of the snapshot is not stored. 345 349 class Snapshot 346 350 { … … 354 358 355 359 ///Default constructor. 356 ///You have to call save() to actually make a snapshot. 360 ///To actually make a snapshot you must call save(). 361 /// 357 362 Snapshot() : _graph(0) {} 358 363 ///Constructor that immediately makes a snapshot 359 364 360 ///This constructor immediately makes a snapshot of the givendigraph.361 /// 362 Snapshot(SmartDigraph &gr ) : _graph(&gr) {365 ///This constructor immediately makes a snapshot of the digraph. 366 ///\param graph The digraph we make a snapshot of. 367 Snapshot(SmartDigraph &graph) : _graph(&graph) { 363 368 node_num=_graph->nodes.size(); 364 369 arc_num=_graph->arcs.size(); … … 367 372 ///Make a snapshot. 368 373 369 ///This function makes a snapshot of the given digraph. 370 ///It can be called more than once. In case of a repeated 374 ///Make a snapshot of the digraph. 375 /// 376 ///This function can be called more than once. In case of a repeated 371 377 ///call, the previous snapshot gets lost. 372 void save(SmartDigraph &gr) { 373 _graph=&gr; 378 ///\param graph The digraph we make the snapshot of. 379 void save(SmartDigraph &graph) 380 { 381 _graph=&graph; 374 382 node_num=_graph->nodes.size(); 375 383 arc_num=_graph->arcs.size(); … … 378 386 ///Undo the changes until a snapshot. 379 387 380 ///This function undos the changes until the last snapshot 381 ///created by save() or Snapshot(SmartDigraph&). 388 ///Undo the changes until a snapshot created by save(). 389 /// 390 ///\note After you restored a state, you cannot restore 391 ///a later state, in other word you cannot add again the arcs deleted 392 ///by restore(). 382 393 void restore() 383 394 { … … 611 622 /// \brief A smart undirected graph class. 612 623 /// 613 /// \ref SmartGraph is a simple and fast graph implementation. 614 /// It is also quite memory efficient but at the price 615 /// that it does not support node and edge deletion 616 /// (except for the Snapshot feature). 624 /// This is a simple and fast graph implementation. 625 /// It is also quite memory efficient, but at the price 626 /// that <b> it does support only limited (only stack-like) 627 /// node and arc deletions</b>. 628 /// It fully conforms to the \ref concepts::Graph "Graph concept". 617 629 /// 618 /// This type fully conforms to the \ref concepts::Graph "Graph concept" 619 /// and it also provides some additional functionalities. 620 /// Most of its member functions and nested classes are documented 621 /// only in the concept class. 622 /// 623 /// \sa concepts::Graph 624 /// \sa SmartDigraph 630 /// \sa concepts::Graph. 625 631 class SmartGraph : public ExtendedSmartGraphBase { 626 632 typedef ExtendedSmartGraphBase Parent; 627 633 628 634 private: 629 /// Graphs are \e not copy constructible. Use GraphCopy instead. 635 636 ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. 637 638 ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. 639 /// 630 640 SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {}; 631 /// \brief Assignment of a graph to another one is \e not allowed. 632 /// Use GraphCopy instead. 641 642 ///\brief Assignment of SmartGraph to another one is \e not allowed. 643 ///Use GraphCopy() instead. 644 645 ///Assignment of SmartGraph to another one is \e not allowed. 646 ///Use GraphCopy() instead. 633 647 void operator=(const SmartGraph &) {} 634 648 … … 641 655 SmartGraph() {} 642 656 643 /// \briefAdd a new node to the graph.644 /// 645 /// This function addsa new node to the graph.657 ///Add a new node to the graph. 658 659 /// Add a new node to the graph. 646 660 /// \return The new node. 647 661 Node addNode() { return Parent::addNode(); } 648 662 649 /// \brief Add a new edge to the graph. 650 /// 651 /// This function adds a new edge to the graph between nodes 652 /// \c u and \c v with inherent orientation from node \c u to 653 /// node \c v. 654 /// \return The new edge. 655 Edge addEdge(Node u, Node v) { 656 return Parent::addEdge(u, v); 663 ///Add a new edge to the graph. 664 665 ///Add a new edge to the graph with node \c s 666 ///and \c t. 667 ///\return The new edge. 668 Edge addEdge(const Node& s, const Node& t) { 669 return Parent::addEdge(s, t); 657 670 } 658 671 659 672 /// \brief Node validity check 660 673 /// 661 /// This function gives back \ctrue if the given node is valid,662 /// i .e. it is a real node of the graph.674 /// This function gives back true if the given node is valid, 675 /// ie. it is a real node of the graph. 663 676 /// 664 677 /// \warning A removed node (using Snapshot) could become valid again 665 /// ifnew nodes are added to the graph.678 /// when new nodes are added to the graph. 666 679 bool valid(Node n) const { return Parent::valid(n); } 667 680 681 /// \brief Arc validity check 682 /// 683 /// This function gives back true if the given arc is valid, 684 /// ie. it is a real arc of the graph. 685 /// 686 /// \warning A removed arc (using Snapshot) could become valid again 687 /// when new edges are added to the graph. 688 bool valid(Arc a) const { return Parent::valid(a); } 689 668 690 /// \brief Edge validity check 669 691 /// 670 /// This function gives back \ctrue if the given edge is valid,671 /// i .e. it is a real edge of the graph.692 /// This function gives back true if the given edge is valid, 693 /// ie. it is a real edge of the graph. 672 694 /// 673 695 /// \warning A removed edge (using Snapshot) could become valid again 674 /// ifnew edges are added to the graph.696 /// when new edges are added to the graph. 675 697 bool valid(Edge e) const { return Parent::valid(e); } 676 698 677 /// \brief Arc validity check678 ///679 /// This function gives back \c true if the given arc is valid,680 /// i.e. it is a real arc of the graph.681 ///682 /// \warning A removed arc (using Snapshot) could become valid again683 /// if new edges are added to the graph.684 bool valid(Arc a) const { return Parent::valid(a); }685 686 699 ///Clear the graph. 687 700 688 /// This function erases all nodes and arcs from the graph.701 ///Erase all the nodes and edges from the graph. 689 702 /// 690 703 void clear() { 691 704 Parent::clear(); 692 705 } 693 694 /// Reserve memory for nodes.695 696 /// Using this function, it is possible to avoid superfluous memory697 /// allocation: if you know that the graph you want to build will698 /// be large (e.g. it will contain millions of nodes and/or edges),699 /// then it is worth reserving space for this amount before starting700 /// to build the graph.701 /// \sa reserveEdge()702 void reserveNode(int n) { nodes.reserve(n); };703 704 /// Reserve memory for edges.705 706 /// Using this function, it is possible to avoid superfluous memory707 /// allocation: if you know that the graph you want to build will708 /// be large (e.g. it will contain millions of nodes and/or edges),709 /// then it is worth reserving space for this amount before starting710 /// to build the graph.711 /// \sa reserveNode()712 void reserveEdge(int m) { arcs.reserve(2 * m); };713 706 714 707 public: … … 750 743 public: 751 744 752 ///Class to make a snapshot of the graph and to restore it later. 753 754 ///Class to make a snapshot of the graph and to restore it later. 755 /// 756 ///The newly added nodes and edges can be removed using the 757 ///restore() function. This is the only way for deleting nodes and/or 758 ///edges from a SmartGraph structure. 759 /// 760 ///\note After a state is restored, you cannot restore a later state, 761 ///i.e. you cannot add the removed nodes and edges again using 762 ///another Snapshot instance. 763 /// 764 ///\warning The validity of the snapshot is not stored due to 765 ///performance reasons. If you do not use the snapshot correctly, 766 ///it can cause broken program, invalid or not restored state of 767 ///the graph or no change. 745 ///Class to make a snapshot of the digraph and to restrore to it later. 746 747 ///Class to make a snapshot of the digraph and to restrore to it later. 748 /// 749 ///The newly added nodes and arcs can be removed using the 750 ///restore() function. 751 /// 752 ///\note After you restore a state, you cannot restore 753 ///a later state, in other word you cannot add again the arcs deleted 754 ///by restore() using another one Snapshot instance. 755 /// 756 ///\warning If you do not use correctly the snapshot that can cause 757 ///either broken program, invalid state of the digraph, valid but 758 ///not the restored digraph or no change. Because the runtime performance 759 ///the validity of the snapshot is not stored. 768 760 class Snapshot 769 761 { … … 777 769 778 770 ///Default constructor. 779 ///You have to call save() to actually make a snapshot. 771 ///To actually make a snapshot you must call save(). 772 /// 780 773 Snapshot() : _graph(0) {} 781 774 ///Constructor that immediately makes a snapshot 782 775 783 /// This constructor immediately makes a snapshot of the given graph. 776 ///This constructor immediately makes a snapshot of the digraph. 777 ///\param graph The digraph we make a snapshot of. 778 Snapshot(SmartGraph &graph) { 779 graph.saveSnapshot(*this); 780 } 781 782 ///Make a snapshot. 783 784 ///Make a snapshot of the graph. 784 785 /// 785 Snapshot(SmartGraph &gr) { 786 gr.saveSnapshot(*this); 787 } 788 789 ///Make a snapshot. 790 791 ///This function makes a snapshot of the given graph. 792 ///It can be called more than once. In case of a repeated 786 ///This function can be called more than once. In case of a repeated 793 787 ///call, the previous snapshot gets lost. 794 void save(SmartGraph &gr) 788 ///\param graph The digraph we make the snapshot of. 789 void save(SmartGraph &graph) 795 790 { 796 gr.saveSnapshot(*this); 797 } 798 799 ///Undo the changes until the last snapshot. 800 801 ///This function undos the changes until the last snapshot 802 ///created by save() or Snapshot(SmartGraph&). 791 graph.saveSnapshot(*this); 792 } 793 794 ///Undo the changes until a snapshot. 795 796 ///Undo the changes until a snapshot created by save(). 797 /// 798 ///\note After you restored a state, you cannot restore 799 ///a later state, in other word you cannot add again the arcs deleted 800 ///by restore(). 803 801 void restore() 804 802 { -
lemon/soplex.cc
r793 r623 92 92 } 93 93 94 int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {95 soplex::DSVector v;96 for (ExprIterator it = b; it != e; ++it) {97 v.add(it->first, it->second);98 }99 soplex::LPRow r(l, v, u);100 soplex->addRow(r);101 102 _row_names.push_back(std::string());103 104 return soplex->nRows() - 1;105 }106 107 94 108 95 void SoplexLp::_eraseCol(int i) { -
lemon/soplex.h
r793 r623 85 85 virtual int _addCol(); 86 86 virtual int _addRow(); 87 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);88 87 89 88 virtual void _eraseCol(int i); -
m4/lx_check_coin.m4
r796 r674 89 89 CBC_LDFLAGS="-L$with_coin/lib" 90 90 fi 91 CBC_LIBS="-lOsi -lCbc -l CbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"91 CBC_LIBS="-lOsi -lCbc -lOsiCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas" 92 92 93 93 lx_save_cxxflags="$CXXFLAGS" -
scripts/chg-len.py
r780 r439 1 1 #! /usr/bin/env python 2 #3 # This file is a part of LEMON, a generic C++ optimization library.4 #5 # Copyright (C) 2003-20096 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport7 # (Egervary Research Group on Combinatorial Optimization, EGRES).8 #9 # Permission to use, modify and distribute this software is granted10 # provided that this copyright notice appears in all copies. For11 # precise terms see the accompanying LICENSE file.12 #13 # This software is provided "AS IS" with no warranty of any kind,14 # express or implied, and with no claim as to its suitability for any15 # purpose.16 2 17 3 import sys -
scripts/mk-release.sh
r780 r611 1 1 #!/bin/bash 2 #3 # This file is a part of LEMON, a generic C++ optimization library.4 #5 # Copyright (C) 2003-20096 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport7 # (Egervary Research Group on Combinatorial Optimization, EGRES).8 #9 # Permission to use, modify and distribute this software is granted10 # provided that this copyright notice appears in all copies. For11 # precise terms see the accompanying LICENSE file.12 #13 # This software is provided "AS IS" with no warranty of any kind,14 # express or implied, and with no claim as to its suitability for any15 # purpose.16 2 17 3 set -e -
scripts/unify-sources.sh
r780 r702 1 1 #!/bin/bash 2 #3 # This file is a part of LEMON, a generic C++ optimization library.4 #5 # Copyright (C) 2003-20096 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport7 # (Egervary Research Group on Combinatorial Optimization, EGRES).8 #9 # Permission to use, modify and distribute this software is granted10 # provided that this copyright notice appears in all copies. For11 # precise terms see the accompanying LICENSE file.12 #13 # This software is provided "AS IS" with no warranty of any kind,14 # express or implied, and with no claim as to its suitability for any15 # purpose.16 2 17 3 YEAR=`date +%Y` -
test/CMakeLists.txt
r817 r726 10 10 SET(TESTS 11 11 adaptors_test 12 bellman_ford_test13 12 bfs_test 14 13 circulation_test … … 33 32 min_cost_arborescence_test 34 33 min_cost_flow_test 35 min_mean_cycle_test36 34 path_test 37 35 preflow_test -
test/Makefile.am
r817 r696 8 8 check_PROGRAMS += \ 9 9 test/adaptors_test \ 10 test/bellman_ford_test \11 10 test/bfs_test \ 12 11 test/circulation_test \ … … 31 30 test/min_cost_arborescence_test \ 32 31 test/min_cost_flow_test \ 33 test/min_mean_cycle_test \34 32 test/path_test \ 35 33 test/preflow_test \ … … 55 53 56 54 test_adaptors_test_SOURCES = test/adaptors_test.cc 57 test_bellman_ford_test_SOURCES = test/bellman_ford_test.cc58 55 test_bfs_test_SOURCES = test/bfs_test.cc 59 56 test_circulation_test_SOURCES = test/circulation_test.cc … … 80 77 test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc 81 78 test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc 82 test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc83 79 test_path_test_SOURCES = test/path_test.cc 84 80 test_preflow_test_SOURCES = test/preflow_test.cc -
test/circulation_test.cc
r736 r658 88 88 .supplyMap(supply) 89 89 .flowMap(flow); 90 91 const CirculationType::Elevator& elev = const_circ_test.elevator();92 circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));93 CirculationType::Tolerance tol = const_circ_test.tolerance();94 circ_test.tolerance(tol);95 90 96 91 circ_test.init(); -
test/digraph_test.cc
r827 r824 37 37 checkGraphArcList(G, 0); 38 38 39 G.reserveNode(3);40 G.reserveArc(4);41 42 39 Node 43 40 n1 = G.addNode(), … … 284 281 G.addNode(); 285 282 snapshot.save(G); 286 287 G.addArc(G.addNode(), G.addNode());288 289 snapshot.restore();290 snapshot.save(G);291 292 checkGraphNodeList(G, 4);293 checkGraphArcList(G, 4);294 283 295 284 G.addArc(G.addNode(), G.addNode()); … … 499 488 typedef FullDigraph Digraph; 500 489 DIGRAPH_TYPEDEFS(Digraph); 501 502 490 Digraph G(num); 503 check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");504 505 G.resize(num);506 check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");507 491 508 492 checkGraphNodeList(G, num); -
test/graph_test.cc
r787 r463 39 39 checkGraphArcList(G, 0); 40 40 41 G.reserveNode(3);42 G.reserveEdge(3);43 44 41 Node 45 42 n1 = G.addNode(), … … 260 257 261 258 snapshot.restore(); 262 snapshot.save(G);263 259 264 260 checkGraphNodeList(G, 4); 265 261 checkGraphEdgeList(G, 3); 266 262 checkGraphArcList(G, 6); 267 268 G.addEdge(G.addNode(), G.addNode());269 270 snapshot.restore();271 272 checkGraphNodeList(G, 4);273 checkGraphEdgeList(G, 3);274 checkGraphArcList(G, 6);275 263 } 276 264 … … 280 268 281 269 Graph G(num); 282 check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,283 "Wrong size");284 285 G.resize(num);286 check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,287 "Wrong size");288 289 270 checkGraphNodeList(G, num); 290 271 checkGraphEdgeList(G, num * (num - 1) / 2); … … 431 412 check(G.height() == height, "Wrong row number"); 432 413 433 G.resize(width, height);434 check(G.width() == width, "Wrong column number");435 check(G.height() == height, "Wrong row number");436 437 414 for (int i = 0; i < width; ++i) { 438 415 for (int j = 0; j < height; ++j) { … … 510 487 511 488 HypercubeGraph G(dim); 512 check(G.dimension() == dim, "Wrong dimension");513 514 G.resize(dim);515 check(G.dimension() == dim, "Wrong dimension");516 517 489 checkGraphNodeList(G, 1 << dim); 518 490 checkGraphEdgeList(G, dim * (1 << (dim-1))); -
test/heap_test.cc
r749 r728 26 26 27 27 #include <lemon/smart_graph.h> 28 28 29 #include <lemon/lgf_reader.h> 29 30 #include <lemon/dijkstra.h> … … 31 32 32 33 #include <lemon/bin_heap.h> 33 #include <lemon/fourary_heap.h>34 #include <lemon/kary_heap.h>35 34 #include <lemon/fib_heap.h> 36 #include <lemon/pairing_heap.h>37 35 #include <lemon/radix_heap.h> 38 #include <lemon/binom_heap.h>39 36 #include <lemon/bucket_heap.h> 40 37 … … 93 90 void heapSortTest() { 94 91 RangeMap<int> map(test_len, -1); 92 95 93 Heap heap(map); 96 94 97 95 std::vector<int> v(test_len); 96 98 97 for (int i = 0; i < test_len; ++i) { 99 98 v[i] = test_seq[i]; … … 102 101 std::sort(v.begin(), v.end()); 103 102 for (int i = 0; i < test_len; ++i) { 104 check(v[i] == heap.prio() ,"Wrong order in heap sort.");103 check(v[i] == heap.prio() ,"Wrong order in heap sort."); 105 104 heap.pop(); 106 105 } … … 114 113 115 114 std::vector<int> v(test_len); 115 116 116 for (int i = 0; i < test_len; ++i) { 117 117 v[i] = test_seq[i]; … … 124 124 std::sort(v.begin(), v.end()); 125 125 for (int i = 0; i < test_len; ++i) { 126 check(v[i] == heap.prio() ,"Wrong order in heap increase test.");126 check(v[i] == heap.prio() ,"Wrong order in heap increase test."); 127 127 heap.pop(); 128 128 } 129 129 } 130 131 130 132 131 133 template <typename Heap> … … 143 145 if (dijkstra.reached(s)) { 144 146 check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a], 145 "Error in shortest path tree.");147 "Error in a shortest path tree!"); 146 148 } 147 149 } … … 152 154 Node s = digraph.source(a); 153 155 check( dijkstra.dist(n) - dijkstra.dist(s) == length[a], 154 "Error in shortest path tree.");156 "Error in a shortest path tree!"); 155 157 } 156 158 } … … 174 176 run(); 175 177 176 // BinHeap177 178 { 178 179 typedef BinHeap<Prio, ItemIntMap> IntHeap; … … 186 187 } 187 188 188 // FouraryHeap189 {190 typedef FouraryHeap<Prio, ItemIntMap> IntHeap;191 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();192 heapSortTest<IntHeap>();193 heapIncreaseTest<IntHeap>();194 195 typedef FouraryHeap<Prio, IntNodeMap > NodeHeap;196 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();197 dijkstraHeapTest<NodeHeap>(digraph, length, source);198 }199 200 // KaryHeap201 {202 typedef KaryHeap<Prio, ItemIntMap> IntHeap;203 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();204 heapSortTest<IntHeap>();205 heapIncreaseTest<IntHeap>();206 207 typedef KaryHeap<Prio, IntNodeMap > NodeHeap;208 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();209 dijkstraHeapTest<NodeHeap>(digraph, length, source);210 }211 212 // FibHeap213 189 { 214 190 typedef FibHeap<Prio, ItemIntMap> IntHeap; … … 222 198 } 223 199 224 // PairingHeap225 {226 typedef PairingHeap<Prio, ItemIntMap> IntHeap;227 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();228 heapSortTest<IntHeap>();229 heapIncreaseTest<IntHeap>();230 231 typedef PairingHeap<Prio, IntNodeMap > NodeHeap;232 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();233 dijkstraHeapTest<NodeHeap>(digraph, length, source);234 }235 236 // RadixHeap237 200 { 238 201 typedef RadixHeap<ItemIntMap> IntHeap; … … 246 209 } 247 210 248 // BinomHeap249 {250 typedef BinomHeap<Prio, ItemIntMap> IntHeap;251 checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();252 heapSortTest<IntHeap>();253 heapIncreaseTest<IntHeap>();254 255 typedef BinomHeap<Prio, IntNodeMap > NodeHeap;256 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();257 dijkstraHeapTest<NodeHeap>(digraph, length, source);258 }259 260 // BucketHeap, SimpleBucketHeap261 211 { 262 212 typedef BucketHeap<ItemIntMap> IntHeap; … … 268 218 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>(); 269 219 dijkstraHeapTest<NodeHeap>(digraph, length, source); 270 271 typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap; 272 heapSortTest<SimpleIntHeap>(); 273 } 220 } 221 274 222 275 223 return 0; -
test/maps_test.cc
r773 r731 24 24 #include <lemon/maps.h> 25 25 #include <lemon/list_graph.h> 26 #include <lemon/smart_graph.h>27 #include <lemon/adaptors.h>28 #include <lemon/dfs.h>29 26 30 27 #include "test_tools.h" … … 64 61 typedef ReadWriteMap<A, bool> BoolWriteMap; 65 62 typedef ReferenceMap<A, bool, bool&, const bool&> BoolRefMap; 66 67 template<typename Map1, typename Map2, typename ItemIt>68 void compareMap(const Map1& map1, const Map2& map2, ItemIt it) {69 for (; it != INVALID; ++it)70 check(map1[it] == map2[it], "The maps are not equal");71 }72 63 73 64 int main() … … 339 330 { 340 331 typedef std::vector<int> vec; 341 checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();342 checkConcept<WriteMap<int, bool>,343 LoggerBoolMap<std::back_insert_iterator<vec> > >();344 345 332 vec v1; 346 333 vec v2(10); … … 362 349 it != map2.end(); ++it ) 363 350 check(v1[i++] == *it, "Something is wrong with LoggerBoolMap"); 364 365 typedef ListDigraph Graph;366 DIGRAPH_TYPEDEFS(Graph);367 Graph gr;368 369 Node n0 = gr.addNode();370 Node n1 = gr.addNode();371 Node n2 = gr.addNode();372 Node n3 = gr.addNode();373 374 gr.addArc(n3, n0);375 gr.addArc(n3, n2);376 gr.addArc(n0, n2);377 gr.addArc(n2, n1);378 gr.addArc(n0, n1);379 380 {381 std::vector<Node> v;382 dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();383 384 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,385 "Something is wrong with LoggerBoolMap");386 }387 {388 std::vector<Node> v(countNodes(gr));389 dfs(gr).processedMap(loggerBoolMap(v.begin())).run();390 391 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,392 "Something is wrong with LoggerBoolMap");393 }394 }395 396 // IdMap, RangeIdMap397 {398 typedef ListDigraph Graph;399 DIGRAPH_TYPEDEFS(Graph);400 401 checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();402 checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();403 checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();404 checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();405 406 Graph gr;407 IdMap<Graph, Node> nmap(gr);408 IdMap<Graph, Arc> amap(gr);409 RangeIdMap<Graph, Node> nrmap(gr);410 RangeIdMap<Graph, Arc> armap(gr);411 412 Node n0 = gr.addNode();413 Node n1 = gr.addNode();414 Node n2 = gr.addNode();415 416 Arc a0 = gr.addArc(n0, n1);417 Arc a1 = gr.addArc(n0, n2);418 Arc a2 = gr.addArc(n2, n1);419 Arc a3 = gr.addArc(n2, n0);420 421 check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");422 check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");423 check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");424 425 check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");426 check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");427 check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");428 check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");429 430 check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");431 check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");432 433 check(nrmap.size() == 3 && armap.size() == 4,434 "Wrong RangeIdMap::size()");435 436 check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");437 check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");438 check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");439 440 check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");441 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");442 check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");443 check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");444 445 check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");446 check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");447 448 gr.erase(n1);449 450 if (nrmap[n0] == 1) nrmap.swap(n0, n2);451 nrmap.swap(n2, n0);452 if (armap[a1] == 1) armap.swap(a1, a3);453 armap.swap(a3, a1);454 455 check(nrmap.size() == 2 && armap.size() == 2,456 "Wrong RangeIdMap::size()");457 458 check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");459 check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");460 461 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");462 check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");463 464 check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");465 check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");466 }467 468 // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap469 {470 typedef ListGraph Graph;471 GRAPH_TYPEDEFS(Graph);472 473 checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();474 checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();475 checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();476 checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();477 checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();478 checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();479 480 Graph gr;481 Node n0 = gr.addNode();482 Node n1 = gr.addNode();483 Node n2 = gr.addNode();484 485 gr.addEdge(n0,n1);486 gr.addEdge(n1,n2);487 gr.addEdge(n0,n2);488 gr.addEdge(n2,n1);489 gr.addEdge(n1,n2);490 gr.addEdge(n0,n1);491 492 for (EdgeIt e(gr); e != INVALID; ++e) {493 check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");494 check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");495 }496 497 compareMap(sourceMap(orienter(gr, constMap<Edge, bool>(true))),498 targetMap(orienter(gr, constMap<Edge, bool>(false))),499 EdgeIt(gr));500 501 typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;502 Digraph dgr(gr, constMap<Edge, bool>(true));503 OutDegMap<Digraph> odm(dgr);504 InDegMap<Digraph> idm(dgr);505 506 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");507 check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");508 509 gr.addEdge(n2, n0);510 511 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");512 check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");513 351 } 514 352 … … 516 354 { 517 355 typedef ListDigraph Graph; 518 DIGRAPH_TYPEDEFS(Graph);519 520 checkConcept<ReadWriteMap<Node, int>,521 CrossRefMap<Graph, Node, int> >();522 checkConcept<ReadWriteMap<Node, bool>,523 CrossRefMap<Graph, Node, bool> >();524 checkConcept<ReadWriteMap<Node, double>,525 CrossRefMap<Graph, Node, double> >();526 527 Graph gr;528 typedef CrossRefMap<Graph, Node, char> CRMap;529 CRMap map(gr);530 531 Node n0 = gr.addNode();532 Node n1 = gr.addNode();533 Node n2 = gr.addNode();534 535 map.set(n0, 'A');536 map.set(n1, 'B');537 map.set(n2, 'C');538 539 check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,540 "Wrong CrossRefMap");541 check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,542 "Wrong CrossRefMap");543 check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,544 "Wrong CrossRefMap");545 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,546 "Wrong CrossRefMap::count()");547 548 CRMap::ValueIt it = map.beginValue();549 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&550 it == map.endValue(), "Wrong value iterator");551 552 map.set(n2, 'A');553 554 check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',555 "Wrong CrossRefMap");556 check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");557 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");558 check(map('C') == INVALID && map.inverse()['C'] == INVALID,559 "Wrong CrossRefMap");560 check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,561 "Wrong CrossRefMap::count()");562 563 it = map.beginValue();564 check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&565 it == map.endValue(), "Wrong value iterator");566 567 map.set(n0, 'C');568 569 check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',570 "Wrong CrossRefMap");571 check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");572 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");573 check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");574 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,575 "Wrong CrossRefMap::count()");576 577 it = map.beginValue();578 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&579 it == map.endValue(), "Wrong value iterator");580 }581 582 // CrossRefMap583 {584 typedef SmartDigraph Graph;585 356 DIGRAPH_TYPEDEFS(Graph); 586 357 … … 613 384 it == map.endValue(), "Wrong value iterator"); 614 385 } 615 616 // Iterable bool map 617 { 618 typedef SmartGraph Graph; 619 typedef SmartGraph::Node Item; 620 621 typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm; 622 checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>(); 623 624 const int num = 10; 625 Graph g; 626 std::vector<Item> items; 627 for (int i = 0; i < num; ++i) { 628 items.push_back(g.addNode()); 629 } 630 631 Ibm map1(g, true); 632 int n = 0; 633 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 634 check(map1[static_cast<Item>(it)], "Wrong TrueIt"); 635 ++n; 636 } 637 check(n == num, "Wrong number"); 638 639 n = 0; 640 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 641 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 642 ++n; 643 } 644 check(n == num, "Wrong number"); 645 check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt"); 646 check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false"); 647 648 map1[items[5]] = true; 649 650 n = 0; 651 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 652 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 653 ++n; 654 } 655 check(n == num, "Wrong number"); 656 657 map1[items[num / 2]] = false; 658 check(map1[items[num / 2]] == false, "Wrong map value"); 659 660 n = 0; 661 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 662 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 663 ++n; 664 } 665 check(n == num - 1, "Wrong number"); 666 667 n = 0; 668 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 669 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 670 ++n; 671 } 672 check(n == 1, "Wrong number"); 673 674 map1[items[0]] = false; 675 check(map1[items[0]] == false, "Wrong map value"); 676 677 map1[items[num - 1]] = false; 678 check(map1[items[num - 1]] == false, "Wrong map value"); 679 680 n = 0; 681 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 682 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 683 ++n; 684 } 685 check(n == num - 3, "Wrong number"); 686 check(map1.trueNum() == num - 3, "Wrong number"); 687 688 n = 0; 689 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 690 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 691 ++n; 692 } 693 check(n == 3, "Wrong number"); 694 check(map1.falseNum() == 3, "Wrong number"); 695 } 696 697 // Iterable int map 698 { 699 typedef SmartGraph Graph; 700 typedef SmartGraph::Node Item; 701 typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim; 702 703 checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>(); 704 705 const int num = 10; 706 Graph g; 707 std::vector<Item> items; 708 for (int i = 0; i < num; ++i) { 709 items.push_back(g.addNode()); 710 } 711 712 Iim map1(g); 713 check(map1.size() == 0, "Wrong size"); 714 715 for (int i = 0; i < num; ++i) { 716 map1[items[i]] = i; 717 } 718 check(map1.size() == num, "Wrong size"); 719 720 for (int i = 0; i < num; ++i) { 721 Iim::ItemIt it(map1, i); 722 check(static_cast<Item>(it) == items[i], "Wrong value"); 723 ++it; 724 check(static_cast<Item>(it) == INVALID, "Wrong value"); 725 } 726 727 for (int i = 0; i < num; ++i) { 728 map1[items[i]] = i % 2; 729 } 730 check(map1.size() == 2, "Wrong size"); 731 732 int n = 0; 733 for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) { 734 check(map1[static_cast<Item>(it)] == 0, "Wrong value"); 735 ++n; 736 } 737 check(n == (num + 1) / 2, "Wrong number"); 738 739 for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) { 740 check(map1[static_cast<Item>(it)] == 1, "Wrong value"); 741 ++n; 742 } 743 check(n == num, "Wrong number"); 744 745 } 746 747 // Iterable value map 748 { 749 typedef SmartGraph Graph; 750 typedef SmartGraph::Node Item; 751 typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm; 752 753 checkConcept<ReadWriteMap<Item, double>, Ivm>(); 754 755 const int num = 10; 756 Graph g; 757 std::vector<Item> items; 758 for (int i = 0; i < num; ++i) { 759 items.push_back(g.addNode()); 760 } 761 762 Ivm map1(g, 0.0); 763 check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size"); 764 check(*map1.beginValue() == 0.0, "Wrong value"); 765 766 for (int i = 0; i < num; ++i) { 767 map1.set(items[i], static_cast<double>(i)); 768 } 769 check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size"); 770 771 for (int i = 0; i < num; ++i) { 772 Ivm::ItemIt it(map1, static_cast<double>(i)); 773 check(static_cast<Item>(it) == items[i], "Wrong value"); 774 ++it; 775 check(static_cast<Item>(it) == INVALID, "Wrong value"); 776 } 777 778 for (Ivm::ValueIt vit = map1.beginValue(); 779 vit != map1.endValue(); ++vit) { 780 check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit, 781 "Wrong ValueIt"); 782 } 783 784 for (int i = 0; i < num; ++i) { 785 map1.set(items[i], static_cast<double>(i % 2)); 786 } 787 check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size"); 788 789 int n = 0; 790 for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) { 791 check(map1[static_cast<Item>(it)] == 0.0, "Wrong value"); 792 ++n; 793 } 794 check(n == (num + 1) / 2, "Wrong number"); 795 796 for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) { 797 check(map1[static_cast<Item>(it)] == 1.0, "Wrong value"); 798 ++n; 799 } 800 check(n == num, "Wrong number"); 801 802 } 386 803 387 return 0; 804 388 } -
test/mip_test.cc
r795 r678 51 51 if (stat == MipSolver::OPTIMAL) { 52 52 std::ostringstream sbuf; 53 sbuf << "Wrong optimal value ("<< mip.solValue() 54 <<" instead of " << exp_opt << ")"; 53 buf << "Wrong optimal value: the right optimum is " << exp_opt; 55 54 check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str()); 56 55 //+ecvt(exp_opt,2) -
test/preflow_test.cc
r736 r632 95 95 PreflowType preflow_test(g, cap, n, n); 96 96 const PreflowType& const_preflow_test = preflow_test; 97 98 const PreflowType::Elevator& elev = const_preflow_test.elevator();99 preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));100 PreflowType::Tolerance tol = const_preflow_test.tolerance();101 preflow_test.tolerance(tol);102 97 103 98 preflow_test -
test/test_tools.h
r810 r463 38 38 ///print something like this (and then exits). 39 39 ///\verbatim file_name.cc:123: error: This is obviously false. \endverbatim 40 #define check(rc, msg) \ 41 { \ 42 if(!(rc)) { \ 43 std::cerr << __FILE__ ":" << __LINE__ << ": error: " \ 44 << msg << std::endl; \ 45 abort(); \ 46 } else { } \ 47 } \ 48 40 #define check(rc, msg) \ 41 if(!(rc)) { \ 42 std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \ 43 abort(); \ 44 } else { } \ 49 45 50 46 #endif -
tools/lemon-0.x-to-1.x.sh
r738 r621 36 36 -e "s/Edge\>/_Ar_c_label_/g"\ 37 37 -e "s/\<edge\>/_ar_c_label_/g"\ 38 -e "s/_edge\>/_ _ar_c_label_/g"\38 -e "s/_edge\>/_ar_c_label_/g"\ 39 39 -e "s/Edges\>/_Ar_c_label_s/g"\ 40 40 -e "s/\<edges\>/_ar_c_label_s/g"\ 41 -e "s/_edges\>/_ _ar_c_label_s/g"\41 -e "s/_edges\>/_ar_c_label_s/g"\ 42 42 -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\ 43 43 -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\ … … 69 69 -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\ 70 70 -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\ 71 -e "s/\<digraph_adaptor\.h\>/adaptors.h/g"\72 -e "s/\<digraph_utils\.h\>/core.h/g"\73 -e "s/\<digraph_reader\.h\>/lgf_reader.h/g"\74 -e "s/\<digraph_writer\.h\>/lgf_writer.h/g"\75 -e "s/\<topology\.h\>/connectivity.h/g"\76 71 -e "s/DigraphToEps/GraphToEps/g"\ 77 72 -e "s/digraphToEps/graphToEps/g"\
Note: See TracChangeset
for help on using the changeset viewer.