Changes in / [837:1870cfd14fb6:838:4e3484a2e90c] in lemon
- Files:
-
- 12 added
- 70 edited
Legend:
- Unmodified
- Added
- Removed
-
CMakeLists.txt
r727 r791 35 35 CHECK_TYPE_SIZE("long long" LONG_LONG) 36 36 SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) 37 38 INCLUDE(FindPythonInterp) 37 39 38 40 ENABLE_TESTING() -
Makefile.am
r676 r799 18 18 cmake/FindGLPK.cmake \ 19 19 cmake/FindCOIN.cmake \ 20 cmake/LEMONConfig.cmake.in \ 20 21 cmake/version.cmake.in \ 21 22 cmake/version.cmake \ -
configure.ac
r727 r791 42 42 43 43 AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) 44 AC_CHECK_PROG([python_found],[python],[yes],[no]) 44 45 AC_CHECK_PROG([gs_found],[gs],[yes],[no]) 45 46 -
doc/CMakeLists.txt
r726 r791 10 10 ) 11 11 12 IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)12 IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND 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.dox 31 32 COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile 32 33 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} -
doc/Doxyfile.in
r379 r803 1 # Doxyfile 1.5. 7.11 # Doxyfile 1.5.9 2 2 3 3 #--------------------------------------------------------------------------- … … 22 22 QT_AUTOBRIEF = NO 23 23 MULTILINE_CPP_IS_BRIEF = NO 24 DETAILS_AT_TOP = YES25 24 INHERIT_DOCS = NO 26 25 SEPARATE_MEMBER_PAGES = NO … … 92 91 "@abs_top_srcdir@/demo" \ 93 92 "@abs_top_srcdir@/tools" \ 94 "@abs_top_srcdir@/test/test_tools.h" 93 "@abs_top_srcdir@/test/test_tools.h" \ 94 "@abs_top_builddir@/doc/references.dox" 95 95 INPUT_ENCODING = UTF-8 96 96 FILE_PATTERNS = *.h \ … … 224 224 SKIP_FUNCTION_MACROS = YES 225 225 #--------------------------------------------------------------------------- 226 # Configuration::additions related to external references226 # Options related to the search engine 227 227 #--------------------------------------------------------------------------- 228 228 TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ " -
doc/Makefile.am
r720 r791 67 67 fi 68 68 69 html-local: $(DOC_PNG_IMAGES) 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 70 82 if test ${doxygen_found} = yes; then \ 71 83 cd doc; \ -
doc/groups.dox
r710 r818 227 227 228 228 /** 229 @defgroup matrices Matrices230 @ingroup datas231 \brief Two dimensional data storages implemented in LEMON.232 233 This group contains two dimensional data storages implemented in LEMON.234 */235 236 /**237 229 @defgroup paths Path Structures 238 230 @ingroup datas … … 247 239 any kind of path structure. 248 240 249 \sa lemon::concepts::Path 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. 250 271 */ 251 272 … … 260 281 261 282 /** 283 @defgroup geomdat Geometric Data Structures 284 @ingroup auxdat 285 \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 dimensional 290 vector with the usual operations. 291 - \ref lemon::dim2::Box "dim2::Box" can be used to determine the 292 rectangular bounding box of a set of \ref lemon::dim2::Point 293 "dim2::Point"'s. 294 */ 295 296 /** 297 @defgroup matrices Matrices 298 @ingroup auxdat 299 \brief Two dimensional data storages implemented in LEMON. 300 301 This group contains two dimensional data storages implemented in LEMON. 302 */ 303 304 /** 262 305 @defgroup algs Algorithms 263 306 \brief This group contains the several algorithms … … 274 317 275 318 This group contains the common graph search algorithms, namely 276 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS). 319 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS) 320 \ref clrs01algorithms. 277 321 */ 278 322 … … 282 326 \brief Algorithms for finding shortest paths. 283 327 284 This group contains the algorithms for finding shortest paths in digraphs. 328 This group contains the algorithms for finding shortest paths in digraphs 329 \ref clrs01algorithms. 285 330 286 331 - \ref Dijkstra algorithm for finding shortest paths from a source node … … 299 344 300 345 /** 346 @defgroup spantree Minimum Spanning Tree Algorithms 347 @ingroup algs 348 \brief Algorithms for finding minimum cost spanning trees and arborescences. 349 350 This group contains the algorithms for finding minimum cost spanning 351 trees and arborescences \ref clrs01algorithms. 352 */ 353 354 /** 301 355 @defgroup max_flow Maximum Flow Algorithms 302 356 @ingroup algs … … 304 358 305 359 This group contains the algorithms for finding maximum flows and 306 feasible circulations .360 feasible circulations \ref clrs01algorithms, \ref amo93networkflows. 307 361 308 362 The \e maximum \e flow \e problem is to find a flow of maximum value between … … 319 373 320 374 LEMON contains several algorithms for solving maximum flow problems: 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 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 327 385 fastest method for computing a maximum flow. All implementations 328 386 also provide functions to query the minimum cut, which is the dual … … 342 400 343 401 This group contains the algorithms for finding minimum cost flows and 344 circulations. For more information about this problem and its dual 345 solution see \ref min_cost_flow "Minimum Cost Flow Problem". 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". 346 405 347 406 LEMON contains several algorithms for this problem. 348 407 - \ref NetworkSimplex Primal Network Simplex algorithm with various 349 pivot strategies .408 pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex. 350 409 - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on 351 cost scaling. 410 cost scaling \ref goldberg90approximation, \ref goldberg97efficient, 411 \ref bunnagel98efficient. 352 412 - \ref CapacityScaling Successive Shortest %Path algorithm with optional 353 capacity scaling. 354 - \ref CancelAndTighten The Cancel and Tighten algorithm. 355 - \ref CycleCanceling Cycle-Canceling algorithms. 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. 356 418 357 419 In general NetworkSimplex is the most efficient implementation, … … 376 438 377 439 \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} 378 \sum_{uv\in A ,u\in X, v\not\in X}cap(uv) \f]440 \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] 379 441 380 442 LEMON contains several algorithms related to minimum cut problems: … … 392 454 393 455 /** 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 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. 415 490 */ 416 491 … … 456 531 457 532 /** 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. 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 554 */ 555 556 /** 557 @defgroup approx Approximation Algorithms 558 @ingroup algs 559 \brief Approximation algorithms. 560 561 This group contains the approximation and heuristic algorithms 562 implemented in LEMON. 464 563 */ 465 564 … … 471 570 This group contains some algorithms implemented in LEMON 472 571 in order to make it easier to implement complex algorithms. 473 */474 475 /**476 @defgroup approx Approximation Algorithms477 @ingroup algs478 \brief Approximation algorithms.479 480 This group contains the approximation and heuristic algorithms481 implemented in LEMON.482 572 */ 483 573 … … 492 582 493 583 /** 494 @defgroup lp_group L p and MipSolvers584 @defgroup lp_group LP and MIP Solvers 495 585 @ingroup gen_opt_group 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. 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. 501 594 */ 502 595 … … 588 681 589 682 /** 590 @defgroup dimacs_group DIMACS format683 @defgroup dimacs_group DIMACS Format 591 684 @ingroup io_group 592 685 \brief Read and write files in DIMACS format … … 637 730 \brief Skeleton and concept checking classes for graph structures 638 731 639 This group contains the skeletons and concept checking classes of LEMON's640 graph structures and helper classes used to implement these.732 This group contains the skeletons and concept checking classes of 733 graph structures. 641 734 */ 642 735 … … 650 743 651 744 /** 745 @defgroup tools Standalone Utility Applications 746 747 Some utility applications are listed here. 748 749 The standard compilation procedure (<tt>./configure;make</tt>) will compile 750 them, as well. 751 */ 752 753 /** 652 754 \anchor demoprograms 653 755 … … 661 763 */ 662 764 663 /**664 @defgroup tools Standalone Utility Applications665 666 Some utility applications are listed here.667 668 The standard compilation procedure (<tt>./configure;make</tt>) will compile669 them, as well.670 */671 672 765 } -
doc/mainpage.dox
r705 r802 22 22 \section intro Introduction 23 23 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. 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. 32 29 33 30 <b> … … 39 36 </b> 40 37 41 \subsection howtoread How to read the documentation 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 42 48 43 49 If you would like to get to know the library, see -
doc/min_cost_flow.dox
r710 r802 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 .29 and arc costs \ref amo93networkflows. 30 30 31 31 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$, -
lemon/Makefile.am
r743 r827 61 61 lemon/bfs.h \ 62 62 lemon/bin_heap.h \ 63 lemon/binom_heap.h \ 63 64 lemon/bucket_heap.h \ 64 65 lemon/cbc.h \ … … 80 81 lemon/euler.h \ 81 82 lemon/fib_heap.h \ 83 lemon/fourary_heap.h \ 82 84 lemon/full_graph.h \ 83 85 lemon/glpk.h \ … … 85 87 lemon/graph_to_eps.h \ 86 88 lemon/grid_graph.h \ 89 lemon/hartmann_orlin.h \ 90 lemon/howard.h \ 87 91 lemon/hypercube_graph.h \ 92 lemon/karp.h \ 93 lemon/kary_heap.h \ 88 94 lemon/kruskal.h \ 89 95 lemon/hao_orlin.h \ … … 94 100 lemon/lp_base.h \ 95 101 lemon/lp_skeleton.h \ 96 lemon/list_graph.h \97 102 lemon/maps.h \ 98 103 lemon/matching.h \ … … 101 106 lemon/nauty_reader.h \ 102 107 lemon/network_simplex.h \ 108 lemon/pairing_heap.h \ 103 109 lemon/path.h \ 104 110 lemon/preflow.h \ … … 108 114 lemon/smart_graph.h \ 109 115 lemon/soplex.h \ 116 lemon/static_graph.h \ 110 117 lemon/suurballe.h \ 111 118 lemon/time_measure.h \ -
lemon/bellman_ford.h
r744 r828 24 24 /// \brief Bellman-Ford algorithm. 25 25 26 #include <lemon/list_graph.h> 26 27 #include <lemon/bits/path_dump.h> 27 28 #include <lemon/core.h> … … 771 772 } 772 773 773 // TODO: implement negative cycle 774 // /// \brief Gives back a negative cycle. 775 // /// 776 // /// This function gives back a negative cycle. 777 // /// If the algorithm have not found yet negative cycle it will give back 778 // /// an empty path. 779 // Path negativeCycle() { 780 // typename Digraph::template NodeMap<int> state(*digraph, 0); 781 // for (ActiveIt it(*this); it != INVALID; ++it) { 782 // if (state[it] == 0) { 783 // for (Node t = it; predArc(t) != INVALID; t = predNode(t)) { 784 // if (state[t] == 0) { 785 // state[t] = 1; 786 // } else if (state[t] == 2) { 787 // break; 788 // } else { 789 // p.clear(); 790 // typename Path::Builder b(p); 791 // b.setStartNode(t); 792 // b.pushFront(predArc(t)); 793 // for(Node s = predNode(t); s != t; s = predNode(s)) { 794 // b.pushFront(predArc(s)); 795 // } 796 // b.commit(); 797 // return true; 798 // } 799 // } 800 // for (Node t = it; predArc(t) != INVALID; t = predNode(t)) { 801 // if (state[t] == 1) { 802 // state[t] = 2; 803 // } else { 804 // break; 805 // } 806 // } 807 // } 808 // } 809 // return false; 810 // } 774 /// \brief Gives back a negative cycle. 775 /// 776 /// This function gives back a directed cycle with negative total 777 /// length if the algorithm has already found one. 778 /// Otherwise it gives back an empty path. 779 lemon::Path<Digraph> negativeCycle() const { 780 typename Digraph::template NodeMap<int> state(*_gr, -1); 781 lemon::Path<Digraph> cycle; 782 for (int i = 0; i < int(_process.size()); ++i) { 783 if (state[_process[i]] != -1) continue; 784 for (Node v = _process[i]; (*_pred)[v] != INVALID; 785 v = _gr->source((*_pred)[v])) { 786 if (state[v] == i) { 787 cycle.addFront((*_pred)[v]); 788 for (Node u = _gr->source((*_pred)[v]); u != v; 789 u = _gr->source((*_pred)[u])) { 790 cycle.addFront((*_pred)[u]); 791 } 792 return cycle; 793 } 794 else if (state[v] >= 0) { 795 break; 796 } 797 state[v] = i; 798 } 799 } 800 return cycle; 801 } 811 802 812 803 ///@} -
lemon/bfs.h
r525 r764 48 48 ///The type of the map that stores the predecessor 49 49 ///arcs of the shortest paths. 50 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.50 ///It must conform to 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 meet the \ref concepts::WriteMap "WriteMap" concept. 65 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 66 ///By default it is a NullMap. 66 67 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; 67 68 ///Instantiates a \c ProcessedMap. … … 82 83 83 84 ///The type of the map that indicates which nodes are reached. 84 ///It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.85 ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 85 86 typedef typename Digraph::template NodeMap<bool> ReachedMap; 86 87 ///Instantiates a \c ReachedMap. … … 97 98 98 99 ///The type of the map that stores the distances of the nodes. 99 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.100 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 100 101 typedef typename Digraph::template NodeMap<int> DistMap; 101 102 ///Instantiates a \c DistMap. … … 226 227 ///\ref named-templ-param "Named parameter" for setting 227 228 ///\c PredMap type. 228 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.229 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 229 230 template <class T> 230 231 struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > { … … 246 247 ///\ref named-templ-param "Named parameter" for setting 247 248 ///\c DistMap type. 248 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.249 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 249 250 template <class T> 250 251 struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > { … … 266 267 ///\ref named-templ-param "Named parameter" for setting 267 268 ///\c ReachedMap type. 268 ///It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.269 ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 269 270 template <class T> 270 271 struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > { … … 286 287 ///\ref named-templ-param "Named parameter" for setting 287 288 ///\c ProcessedMap type. 288 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.289 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 289 290 template <class T> 290 291 struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > { … … 414 415 ///The simplest way to execute the BFS algorithm is to use one of the 415 416 ///member functions called \ref run(Node) "run()".\n 416 ///If you need more control on the execution, firstyou have to call417 ///\ref init() , then you can add several source nodes with417 ///If you need better control on the execution, you have to call 418 ///\ref init() first, then you can add several source nodes with 418 419 ///\ref addSource(). Finally the actual path computation can be 419 420 ///performed with one of the \ref start() functions. … … 738 739 ///@{ 739 740 740 ///The shortest path to anode.741 742 ///Returns the shortest path to a node.741 ///The shortest path to the given node. 742 743 ///Returns the shortest path to the given node from the root(s). 743 744 /// 744 745 ///\warning \c t should be reached from the root(s). … … 748 749 Path path(Node t) const { return Path(*G, *_pred, t); } 749 750 750 ///The distance of anode from the root(s).751 752 ///Returns the distance of anode from the root(s).751 ///The distance of the given node from the root(s). 752 753 ///Returns the distance of the given node from the root(s). 753 754 /// 754 755 ///\warning If node \c v is not reached from the root(s), then … … 759 760 int dist(Node v) const { return (*_dist)[v]; } 760 761 761 ///Returns the 'previous arc' of the shortest path tree for a node. 762 762 ///\brief Returns the 'previous arc' of the shortest path tree for 763 ///the given node. 764 /// 763 765 ///This function returns the 'previous arc' of the shortest path 764 766 ///tree for the node \c v, i.e. it returns the last arc of a … … 767 769 /// 768 770 ///The shortest path tree used here is equal to the shortest path 769 ///tree used in \ref predNode() .771 ///tree used in \ref predNode() and \ref predMap(). 770 772 /// 771 773 ///\pre Either \ref run(Node) "run()" or \ref init() … … 773 775 Arc predArc(Node v) const { return (*_pred)[v];} 774 776 775 ///Returns the 'previous node' of the shortest path tree for a node. 776 777 ///\brief Returns the 'previous node' of the shortest path tree for 778 ///the given node. 779 /// 777 780 ///This function returns the 'previous node' of the shortest path 778 781 ///tree for the node \c v, i.e. it returns the last but one node 779 /// froma shortest path from a root to \c v. It is \c INVALID782 ///of a shortest path from a root to \c v. It is \c INVALID 780 783 ///if \c v is not reached from the root(s) or if \c v is a root. 781 784 /// 782 785 ///The shortest path tree used here is equal to the shortest path 783 ///tree used in \ref predArc() .786 ///tree used in \ref predArc() and \ref predMap(). 784 787 /// 785 788 ///\pre Either \ref run(Node) "run()" or \ref init() … … 802 805 /// 803 806 ///Returns a const reference to the node map that stores the predecessor 804 ///arcs, which form the shortest path tree .807 ///arcs, which form the shortest path tree (forest). 805 808 /// 806 809 ///\pre Either \ref run(Node) "run()" or \ref init() … … 808 811 const PredMap &predMap() const { return *_pred;} 809 812 810 ///Checks if anode is reached from the root(s).813 ///Checks if the given node is reached from the root(s). 811 814 812 815 ///Returns \c true if \c v is reached from the root(s). … … 834 837 ///The type of the map that stores the predecessor 835 838 ///arcs of the shortest paths. 836 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.839 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 837 840 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 838 841 ///Instantiates a PredMap. … … 849 852 850 853 ///The type of the map that indicates which nodes are processed. 851 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.854 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 852 855 ///By default it is a NullMap. 853 856 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 869 872 870 873 ///The type of the map that indicates which nodes are reached. 871 ///It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.874 ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 872 875 typedef typename Digraph::template NodeMap<bool> ReachedMap; 873 876 ///Instantiates a ReachedMap. … … 884 887 885 888 ///The type of the map that stores the distances of the nodes. 886 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.889 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 887 890 typedef typename Digraph::template NodeMap<int> DistMap; 888 891 ///Instantiates a DistMap. … … 899 902 900 903 ///The type of the shortest paths. 901 ///It must meetthe \ref concepts::Path "Path" concept.904 ///It must conform to the \ref concepts::Path "Path" concept. 902 905 typedef lemon::Path<Digraph> Path; 903 906 }; … … 905 908 /// Default traits class used by BfsWizard 906 909 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. 910 /// Default traits class used by BfsWizard. 911 /// \tparam GR The type of the digraph. 913 912 template<class GR> 914 913 class BfsWizardBase : public BfsWizardDefaultTraits<GR> … … 938 937 /// Constructor. 939 938 940 /// This constructor does not require parameters, thereforeit initiates939 /// This constructor does not require parameters, it initiates 941 940 /// all of the attributes to \c 0. 942 941 BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), … … 968 967 typedef TR Base; 969 968 970 ///The type of the digraph the algorithm runs on.971 969 typedef typename TR::Digraph Digraph; 972 970 … … 976 974 typedef typename Digraph::OutArcIt OutArcIt; 977 975 978 ///\brief The type of the map that stores the predecessor979 ///arcs of the shortest paths.980 976 typedef typename TR::PredMap PredMap; 981 ///\brief The type of the map that stores the distances of the nodes.982 977 typedef typename TR::DistMap DistMap; 983 ///\brief The type of the map that indicates which nodes are reached.984 978 typedef typename TR::ReachedMap ReachedMap; 985 ///\brief The type of the map that indicates which nodes are processed.986 979 typedef typename TR::ProcessedMap ProcessedMap; 987 ///The type of the shortest paths988 980 typedef typename TR::Path Path; 989 981 … … 1068 1060 SetPredMapBase(const TR &b) : TR(b) {} 1069 1061 }; 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. 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. 1075 1068 template<class T> 1076 1069 BfsWizard<SetPredMapBase<T> > predMap(const T &t) … … 1086 1079 SetReachedMapBase(const TR &b) : TR(b) {} 1087 1080 }; 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. 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. 1093 1087 template<class T> 1094 1088 BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) … … 1104 1098 SetDistMapBase(const TR &b) : TR(b) {} 1105 1099 }; 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. 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. 1111 1107 template<class T> 1112 1108 BfsWizard<SetDistMapBase<T> > distMap(const T &t) … … 1122 1118 SetProcessedMapBase(const TR &b) : TR(b) {} 1123 1119 }; 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. 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. 1129 1126 template<class T> 1130 1127 BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1265 1262 /// 1266 1263 /// The type of the map that indicates which nodes are reached. 1267 /// It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.1264 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 1268 1265 typedef typename Digraph::template NodeMap<bool> ReachedMap; 1269 1266 … … 1426 1423 /// The simplest way to execute the BFS algorithm is to use one of the 1427 1424 /// member functions called \ref run(Node) "run()".\n 1428 /// If you need more control on the execution, firstyou have to call1429 /// \ref init() , then you can add several source nodes with1425 /// If you need better control on the execution, you have to call 1426 /// \ref init() first, then you can add several source nodes with 1430 1427 /// \ref addSource(). Finally the actual path computation can be 1431 1428 /// performed with one of the \ref start() functions. … … 1736 1733 ///@{ 1737 1734 1738 /// \brief Checks if anode is reached from the root(s).1735 /// \brief Checks if the given node is reached from the root(s). 1739 1736 /// 1740 1737 /// Returns \c true if \c v is reached from the root(s). -
lemon/bin_heap.h
r730 r758 20 20 #define LEMON_BIN_HEAP_H 21 21 22 ///\ingroup auxdat22 ///\ingroup heaps 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 auxdat32 /// \ingroup heaps 33 33 /// 34 /// \brief A Binary Heap implementation.34 /// \brief Binary heap data structure. 35 35 /// 36 ///This class implements the \e binary \e heap data structure. 36 /// This class implements the \e binary \e heap data structure. 37 /// It fully conforms to the \ref concepts::Heap "heap concept". 37 38 /// 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 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 52 47 template <typename PR, typename IM, typename CMP = std::less<PR> > 48 #endif 53 49 class BinHeap { 54 55 50 public: 56 ///\e 51 52 /// Type of the item-int map. 57 53 typedef IM ItemIntMap; 58 /// \e54 /// Type of the priorities. 59 55 typedef PR Prio; 60 /// \e56 /// Type of the items stored in the heap. 61 57 typedef typename ItemIntMap::Key Item; 62 /// \e58 /// Type of the item-priority pairs. 63 59 typedef std::pair<Item,Prio> Pair; 64 /// \e60 /// Functor type for comparing the priorities. 65 61 typedef CMP Compare; 66 62 67 /// \brief Type to represent the items states.68 /// 69 /// Each Item element have a state associated to it. It maybe "in heap",70 /// "pre heap" or "postheap". The latter two are indifferent from the63 /// \brief Type to represent the states of the items. 64 /// 65 /// Each item has a state associated to it. It can be "in heap", 66 /// "pre-heap" or "post-heap". The latter two are indifferent from the 71 67 /// heap's point of view, but may be useful to the user. 72 68 /// … … 85 81 86 82 public: 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. 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. 93 90 explicit BinHeap(ItemIntMap &map) : _iim(map) {} 94 91 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. 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. 103 99 BinHeap(ItemIntMap &map, const Compare &comp) 104 100 : _iim(map), _comp(comp) {} 105 101 106 102 107 /// The number of items stored in the heap.108 /// 109 /// \brief Returns the number of items stored in the heap.103 /// \brief The number of items stored in the heap. 104 /// 105 /// This function returns the number of items stored in the heap. 110 106 int size() const { return _data.size(); } 111 107 112 /// \brief Check s if the heap stores no items.113 /// 114 /// Returns \c true if and only if the heap stores no items.108 /// \brief Check if the heap is empty. 109 /// 110 /// This function returns \c true if the heap is empty. 115 111 bool empty() const { return _data.empty(); } 116 112 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. 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. 123 120 void clear() { 124 121 _data.clear(); … … 128 125 static int parent(int i) { return (i-1)/2; } 129 126 130 static int second _child(int i) { return 2*i+2; }127 static int secondChild(int i) { return 2*i+2; } 131 128 bool less(const Pair &p1, const Pair &p2) const { 132 129 return _comp(p1.second, p2.second); 133 130 } 134 131 135 int bubble _up(int hole, Pair p) {132 int bubbleUp(int hole, Pair p) { 136 133 int par = parent(hole); 137 134 while( hole>0 && less(p,_data[par]) ) { … … 144 141 } 145 142 146 int bubble _down(int hole, Pair p, int length) {147 int child = second _child(hole);143 int bubbleDown(int hole, Pair p, int length) { 144 int child = secondChild(hole); 148 145 while(child < length) { 149 146 if( less(_data[child-1], _data[child]) ) { … … 154 151 move(_data[child], hole); 155 152 hole = child; 156 child = second _child(hole);153 child = secondChild(hole); 157 154 } 158 155 child--; … … 172 169 173 170 public: 171 174 172 /// \brief Insert a pair of item and priority into the heap. 175 173 /// 176 /// Adds \c p.first to the heap with priority \c p.second. 174 /// This function inserts \c p.first to the heap with priority 175 /// \c p.second. 177 176 /// \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 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. 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. 187 188 /// \param i The item to insert. 188 189 /// \param p The priority of the item. 190 /// \pre \e i must not be stored in the heap. 189 191 void push(const Item &i, const Prio &p) { push(Pair(i,p)); } 190 192 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. 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. 196 197 Item top() const { 197 198 return _data[0].first; 198 199 } 199 200 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 non empty.201 /// \brief The minimum priority. 202 /// 203 /// This function returns the minimum priority. 204 /// \pre The heap must be non-empty. 204 205 Prio prio() const { 205 206 return _data[0].second; 206 207 } 207 208 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. 209 /// \brief Remove the item having minimum priority. 210 /// 211 /// This function removes the item having minimum priority. 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 bubbleDown(0, _data[n], n); 218 218 } 219 219 _data.pop_back(); 220 220 } 221 221 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. 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. 227 228 void erase(const Item &i) { 228 229 int h = _iim[i]; … … 230 231 _iim.set(_data[h].first, POST_HEAP); 231 232 if( h < n ) { 232 if ( bubble _up(h, _data[n]) == h) {233 bubble _down(h, _data[n], n);233 if ( bubbleUp(h, _data[n]) == h) { 234 bubbleDown(h, _data[n], n); 234 235 } 235 236 } … … 237 238 } 238 239 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. 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. 245 245 Prio operator[](const Item &i) const { 246 246 int idx = _iim[i]; … … 248 248 } 249 249 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. 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. 255 256 /// \param i The item. 256 257 /// \param p The priority. … … 261 262 } 262 263 else if( _comp(p, _data[idx].second) ) { 263 bubble _up(idx, Pair(i,p));264 bubbleUp(idx, Pair(i,p)); 264 265 } 265 266 else { 266 bubble _down(idx, Pair(i,p), _data.size());267 } 268 } 269 270 /// \brief Decrease s the priority of \c i to \c p.271 /// 272 /// This method decreases the priority of item \c i to \c p.267 bubbleDown(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. 273 274 /// \param i The item. 274 275 /// \param p The priority. 275 /// \pre \c i must be stored in the heap with priority at least \c 276 /// p relative to \c Compare. 276 /// \pre \e i must be stored in the heap with priority at least \e p. 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 s the priority of \c i to \c p.283 /// 284 /// This method sets the priority of item \c i to \c p.279 bubbleUp(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. 285 285 /// \param i The item. 286 286 /// \param p The priority. 287 /// \pre \c i must be stored in the heap with priority at most \c 288 /// p relative to \c Compare. 287 /// \pre \e i must be stored in the heap with priority at most \e p. 289 288 void increase(const Item &i, const Prio &p) { 290 289 int idx = _iim[i]; 291 bubble _down(idx, Pair(i,p), _data.size());292 } 293 294 /// \brief Return s if \c item is in, has already been in, or has295 /// never been in the heap.296 /// 297 /// This method returns PRE_HEAP if \c item has never been in the298 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP299 /// otherwise. In the latter case it is possible that \c item will300 /// get backto the heap again.290 bubbleDown(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 never 296 /// 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 back 299 /// to the heap again. 301 300 /// \param i The item. 302 301 State state(const Item &i) const { … … 307 306 } 308 307 309 /// \brief Set s the state of the \citem in the heap.310 /// 311 /// Sets the state of the \c item in the heap. It can be used to312 /// manually clear the heap when it is important to achive the313 /// better time complexity.308 /// \brief Set the state of an item 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 important 312 /// to achive better time complexity. 314 313 /// \param i The item. 315 314 /// \param st The state. It should not be \c IN_HEAP. … … 328 327 } 329 328 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. 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. 336 336 void replace(const Item& i, const Item& j) { 337 337 int idx = _iim[i]; -
lemon/bits/edge_set_extender.h
r664 r732 538 538 539 539 public: 540 ArcMap(const Graph& _g)540 explicit ArcMap(const Graph& _g) 541 541 : Parent(_g) {} 542 542 ArcMap(const Graph& _g, const _Value& _v) … … 562 562 563 563 public: 564 EdgeMap(const Graph& _g)564 explicit EdgeMap(const Graph& _g) 565 565 : Parent(_g) {} 566 566 -
lemon/bits/graph_extender.h
r664 r825 57 57 } 58 58 59 Node fromId(int id, Node) const{59 static Node fromId(int id, Node) { 60 60 return Parent::nodeFromId(id); 61 61 } 62 62 63 Arc fromId(int id, Arc) const{63 static Arc fromId(int id, Arc) { 64 64 return Parent::arcFromId(id); 65 65 } … … 356 356 } 357 357 358 Node fromId(int id, Node) const{358 static Node fromId(int id, Node) { 359 359 return Parent::nodeFromId(id); 360 360 } 361 361 362 Arc fromId(int id, Arc) const{362 static Arc fromId(int id, Arc) { 363 363 return Parent::arcFromId(id); 364 364 } 365 365 366 Edge fromId(int id, Edge) const{366 static Edge fromId(int id, Edge) { 367 367 return Parent::edgeFromId(id); 368 368 } … … 605 605 606 606 public: 607 NodeMap(const Graph& graph)607 explicit NodeMap(const Graph& graph) 608 608 : Parent(graph) {} 609 609 NodeMap(const Graph& graph, const _Value& value) … … 629 629 630 630 public: 631 ArcMap(const Graph& graph)631 explicit ArcMap(const Graph& graph) 632 632 : Parent(graph) {} 633 633 ArcMap(const Graph& graph, const _Value& value) … … 653 653 654 654 public: 655 EdgeMap(const Graph& graph)655 explicit EdgeMap(const Graph& graph) 656 656 : Parent(graph) {} 657 657 -
lemon/bits/map_extender.h
r664 r765 50 50 typedef typename Parent::ConstReference ConstReference; 51 51 52 typedef typename Parent::ReferenceMapTag ReferenceMapTag; 53 52 54 class MapIt; 53 55 class ConstMapIt; … … 192 194 typedef typename Parent::ConstReference ConstReference; 193 195 196 typedef typename Parent::ReferenceMapTag ReferenceMapTag; 197 194 198 class MapIt; 195 199 class ConstMapIt; -
lemon/bucket_heap.h
r730 r758 20 20 #define LEMON_BUCKET_HEAP_H 21 21 22 ///\ingroup auxdat22 ///\ingroup heaps 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 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. 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 73 78 template <typename IM, bool MIN = true> 74 79 class BucketHeap { 75 80 76 81 public: 77 /// \e 78 typedef typename IM::Key Item; 79 /// \e 82 83 /// Type of the item-int map. 84 typedef IM ItemIntMap; 85 /// Type of the priorities. 80 86 typedef int Prio; 81 /// \e82 typedef std::pair<Item, Prio> Pair;83 /// \e84 typedef IM ItemIntMap;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; 85 91 86 92 private: … … 90 96 public: 91 97 92 /// \brief Type to represent the items states.93 /// 94 /// Each Item element have a state associated to it. It maybe "in heap",95 /// "pre heap" or "postheap". The latter two are indifferent from the98 /// \brief Type to represent the states of the items. 99 /// 100 /// Each item has a state associated to it. It can be "in heap", 101 /// "pre-heap" or "post-heap". The latter two are indifferent from the 96 102 /// heap's point of view, but may be useful to the user. 97 103 /// … … 105 111 106 112 public: 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. 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. 113 120 explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {} 114 121 115 /// The number of items stored in the heap.116 /// 117 /// \brief Returns the number of items stored in the heap.122 /// \brief The number of items stored in the heap. 123 /// 124 /// This function returns the number of items stored in the heap. 118 125 int size() const { return _data.size(); } 119 126 120 /// \brief Check s if the heap stores no items.121 /// 122 /// Returns \c true if and only if the heap stores no items.127 /// \brief Check if the heap is empty. 128 /// 129 /// This function returns \c true if the heap is empty. 123 130 bool empty() const { return _data.empty(); } 124 131 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. 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. 131 139 void clear() { 132 140 _data.clear(); _first.clear(); _minimum = 0; … … 135 143 private: 136 144 137 void relocate _last(int idx) {145 void relocateLast(int idx) { 138 146 if (idx + 1 < int(_data.size())) { 139 147 _data[idx] = _data.back(); … … 175 183 176 184 public: 185 177 186 /// \brief Insert a pair of item and priority into the heap. 178 187 /// 179 /// Adds \c p.first to the heap with priority \c p.second. 188 /// This function inserts \c p.first to the heap with priority 189 /// \c p.second. 180 190 /// \param p The pair to insert. 191 /// \pre \c p.first must not be stored in the heap. 181 192 void push(const Pair& p) { 182 193 push(p.first, p.second); … … 185 196 /// \brief Insert an item into the heap with the given priority. 186 197 /// 187 /// Adds \c i to the heap with priority \c p. 198 /// This function inserts the given item into the heap with the 199 /// given priority. 188 200 /// \param i The item to insert. 189 201 /// \param p The priority of the item. 202 /// \pre \e i must not be stored in the heap. 190 203 void push(const Item &i, const Prio &p) { 191 204 int idx = _data.size(); … … 198 211 } 199 212 200 /// \brief Return s the item withminimum priority.201 /// 202 /// This method returns the item withminimum priority.203 /// \pre The heap must be non empty.213 /// \brief Return the item having minimum priority. 214 /// 215 /// This function returns the item having minimum priority. 216 /// \pre The heap must be non-empty. 204 217 Item top() const { 205 218 while (_first[_minimum] == -1) { … … 209 222 } 210 223 211 /// \brief Returns the minimum priority.212 /// 213 /// Itreturns the minimum priority.214 /// \pre The heap must be non empty.224 /// \brief The minimum priority. 225 /// 226 /// This function returns the minimum priority. 227 /// \pre The heap must be non-empty. 215 228 Prio prio() const { 216 229 while (_first[_minimum] == -1) { … … 220 233 } 221 234 222 /// \brief Deletes the item withminimum priority.223 /// 224 /// This method deletes the item with minimum priority from the heap.235 /// \brief Remove the item having minimum priority. 236 /// 237 /// This function removes the item having minimum priority. 225 238 /// \pre The heap must be non-empty. 226 239 void pop() { … … 231 244 _iim[_data[idx].item] = -2; 232 245 unlace(idx); 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. 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. 241 255 void erase(const Item &i) { 242 256 int idx = _iim[i]; 243 257 _iim[_data[idx].item] = -2; 244 258 unlace(idx); 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. 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. 254 267 Prio operator[](const Item &i) const { 255 268 int idx = _iim[i]; … … 257 270 } 258 271 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. 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. 264 278 /// \param i The item. 265 279 /// \param p The priority. … … 275 289 } 276 290 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. 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. 282 294 /// \param i The item. 283 295 /// \param p The priority. 296 /// \pre \e i must be stored in the heap with priority at least \e p. 284 297 void decrease(const Item &i, const Prio &p) { 285 298 int idx = _iim[i]; … … 292 305 } 293 306 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. 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. 299 310 /// \param i The item. 300 311 /// \param p The priority. 312 /// \pre \e i must be stored in the heap with priority at most \e p. 301 313 void increase(const Item &i, const Prio &p) { 302 314 int idx = _iim[i]; … … 306 318 } 307 319 308 /// \brief Return s if \c item is in, has already been in, or has309 /// never been in the heap.310 /// 311 /// This method returns PRE_HEAP if \c item has never been in the312 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP313 /// otherwise. In the latter case it is possible that \c item will314 /// get backto the heap again.320 /// \brief Return the state of an item. 321 /// 322 /// This method returns \c PRE_HEAP if the given item has never 323 /// 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 back 326 /// to the heap again. 315 327 /// \param i The item. 316 328 State state(const Item &i) const { … … 320 332 } 321 333 322 /// \brief Set s the state of the \citem in the heap.323 /// 324 /// Sets the state of the \c item in the heap. It can be used to325 /// manually clear the heap when it is important to achive the326 /// better time complexity.334 /// \brief Set the state of an item 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 important 338 /// to achive better time complexity. 327 339 /// \param i The item. 328 340 /// \param st The state. It should not be \c IN_HEAP. … … 360 372 }; // class BucketHeap 361 373 362 /// \ingroup auxdat363 /// 364 /// \brief A Simplified Bucket Heap implementation.374 /// \ingroup heaps 375 /// 376 /// \brief Simplified bucket heap data structure. 365 377 /// 366 378 /// This class implements a simplified \e bucket \e heap data 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. 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. 379 397 /// 380 398 /// \sa BucketHeap … … 383 401 384 402 public: 385 typedef typename IM::Key Item; 403 404 /// Type of the item-int map. 405 typedef IM ItemIntMap; 406 /// Type of the priorities. 386 407 typedef int Prio; 387 typedef std::pair<Item, Prio> Pair; 388 typedef IM ItemIntMap; 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; 389 412 390 413 private: … … 394 417 public: 395 418 396 /// \brief Type to represent the items states.397 /// 398 /// Each Item element have a state associated to it. It maybe "in heap",399 /// "pre heap" or "postheap". The latter two are indifferent from the419 /// \brief Type to represent the states of the items. 420 /// 421 /// Each item has a state associated to it. It can be "in heap", 422 /// "pre-heap" or "post-heap". The latter two are indifferent from the 400 423 /// heap's point of view, but may be useful to the user. 401 424 /// … … 410 433 public: 411 434 412 /// \brief The constructor.413 /// 414 /// The constructor.415 /// \param map should be given to the constructor, since it is used416 /// internally to handle the cross references. The value of the map417 /// should be PRE_HEAP (-1) for each element.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. 418 441 explicit SimpleBucketHeap(ItemIntMap &map) 419 442 : _iim(map), _free(-1), _num(0), _minimum(0) {} 420 443 421 /// \brief Returns the number of items stored in the heap.422 /// 423 /// Th e number of items stored in the heap.444 /// \brief The number of items stored in the heap. 445 /// 446 /// This function returns the number of items stored in the heap. 424 447 int size() const { return _num; } 425 448 426 /// \brief Check s if the heap stores no items.427 /// 428 /// Returns \c true if and only if the heap stores no items.449 /// \brief Check if the heap is empty. 450 /// 451 /// This function returns \c true if the heap is empty. 429 452 bool empty() const { return _num == 0; } 430 453 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. 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. 437 461 void clear() { 438 462 _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0; … … 441 465 /// \brief Insert a pair of item and priority into the heap. 442 466 /// 443 /// Adds \c p.first to the heap with priority \c p.second. 467 /// This function inserts \c p.first to the heap with priority 468 /// \c p.second. 444 469 /// \param p The pair to insert. 470 /// \pre \c p.first must not be stored in the heap. 445 471 void push(const Pair& p) { 446 472 push(p.first, p.second); … … 449 475 /// \brief Insert an item into the heap with the given priority. 450 476 /// 451 /// Adds \c i to the heap with priority \c p. 477 /// This function inserts the given item into the heap with the 478 /// given priority. 452 479 /// \param i The item to insert. 453 480 /// \param p The priority of the item. 481 /// \pre \e i must not be stored in the heap. 454 482 void push(const Item &i, const Prio &p) { 455 483 int idx; … … 472 500 } 473 501 474 /// \brief Return s the item withminimum priority.475 /// 476 /// This method returns the item withminimum priority.477 /// \pre The heap must be non empty.502 /// \brief Return the item having minimum priority. 503 /// 504 /// This function returns the item having minimum priority. 505 /// \pre The heap must be non-empty. 478 506 Item top() const { 479 507 while (_first[_minimum] == -1) { … … 483 511 } 484 512 485 /// \brief Returns the minimum priority.486 /// 487 /// Itreturns the minimum priority.488 /// \pre The heap must be non empty.513 /// \brief The minimum priority. 514 /// 515 /// This function returns the minimum priority. 516 /// \pre The heap must be non-empty. 489 517 Prio prio() const { 490 518 while (_first[_minimum] == -1) { … … 494 522 } 495 523 496 /// \brief Deletes the item withminimum priority.497 /// 498 /// This method deletes the item with minimum priority from the heap.524 /// \brief Remove the item having minimum priority. 525 /// 526 /// This function removes the item having minimum priority. 499 527 /// \pre The heap must be non-empty. 500 528 void pop() { … … 510 538 } 511 539 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. 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. 520 547 Prio operator[](const Item &i) const { 521 for (int k = 0; k < _first.size(); ++k) {548 for (int k = 0; k < int(_first.size()); ++k) { 522 549 int idx = _first[k]; 523 550 while (idx != -1) { … … 531 558 } 532 559 533 /// \brief Return s if \c item is in, has already been in, or has534 /// never been in the heap.535 /// 536 /// This method returns PRE_HEAP if \c item has never been in the537 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP538 /// otherwise. In the latter case it is possible that \c item will539 /// get backto the heap again.560 /// \brief Return the state of an item. 561 /// 562 /// This method returns \c PRE_HEAP if the given item has never 563 /// 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 back 566 /// to the heap again. 540 567 /// \param i The item. 541 568 State state(const Item &i) const { -
lemon/cbc.cc
r623 r793 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 } 97 109 98 110 void CbcMip::_eraseCol(int i) { -
lemon/cbc.h
r623 r793 63 63 virtual int _addCol(); 64 64 virtual int _addRow(); 65 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); 65 66 66 67 virtual void _eraseCol(int i); -
lemon/circulation.h
r688 r762 73 73 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" 74 74 /// concept. 75 #ifdef DOXYGEN 76 typedef GR::ArcMap<Value> FlowMap; 77 #else 75 78 typedef typename Digraph::template ArcMap<Value> FlowMap; 79 #endif 76 80 77 81 /// \brief Instantiates a FlowMap. … … 88 92 /// The elevator type used by the algorithm. 89 93 /// 90 /// \sa Elevator 91 /// \sa LinkedElevator 94 /// \sa Elevator, LinkedElevator 95 #ifdef DOXYGEN 96 typedef lemon::Elevator<GR, GR::Node> Elevator; 97 #else 92 98 typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator; 99 #endif 93 100 94 101 /// \brief Instantiates an Elevator. … … 451 458 } 452 459 453 /// \brief Sets the tolerance used by algorithm. 454 /// 455 /// Sets the tolerance used by algorithm. 456 Circulation& tolerance(const Tolerance& tolerance) const { 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) { 457 465 _tol = tolerance; 458 466 return *this; … … 461 469 /// \brief Returns a const reference to the tolerance. 462 470 /// 463 /// Returns a const reference to the tolerance. 471 /// Returns a const reference to the tolerance object used by 472 /// the algorithm. 464 473 const Tolerance& tolerance() const { 465 return tolerance;474 return _tol; 466 475 } 467 476 468 477 /// \name Execution Control 469 478 /// The simplest way to execute the algorithm is to call \ref run().\n 470 /// If you need morecontrol on the initial solution or the execution,471 /// first you have to call one of the \ref init() functions, then479 /// If you need better control on the initial solution or the execution, 480 /// you have to call one of the \ref init() functions first, then 472 481 /// the \ref start() function. 473 482 -
lemon/clp.cc
r623 r793 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 81 94 82 95 void ClpLp::_eraseCol(int c) { -
lemon/clp.h
r623 r793 76 76 virtual int _addCol(); 77 77 virtual int _addRow(); 78 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); 78 79 79 80 virtual void _eraseCol(int i); -
lemon/concepts/digraph.h
r627 r781 36 36 /// \brief Class describing the concept of directed graphs. 37 37 /// 38 /// This class describes the \ref concept "concept" of the39 /// immutable directed digraphs.38 /// This class describes the common interface of all directed 39 /// graphs (digraphs). 40 40 /// 41 /// Note that actual digraph implementation like @ref ListDigraph or 42 /// @ref SmartDigraph may have several additional functionality. 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. 43 47 /// 44 /// \sa concept48 /// \sa Graph 45 49 class Digraph { 46 50 private: 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 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. 58 55 void operator=(const Digraph &) {} 56 59 57 public: 60 ///\e 61 62 /// Defalult constructor. 63 64 /// Defalult constructor. 65 /// 58 /// Default constructor. 66 59 Digraph() { } 67 /// Class for identifying a node of the digraph 60 61 /// The node type of the digraph 68 62 69 63 /// This class identifies a node of the digraph. It also serves 70 64 /// as a base class of the node iterators, 71 /// thus they willconvert to this type.65 /// thus they convert to this type. 72 66 class Node { 73 67 public: 74 68 /// Default constructor 75 69 76 /// @warning The default constructor sets the iterator77 /// to an undefined value.70 /// Default constructor. 71 /// \warning It sets the object to an undefined value. 78 72 Node() { } 79 73 /// Copy constructor. … … 83 77 Node(const Node&) { } 84 78 85 /// Invalid constructor \& conversion.86 87 /// This constructor initializes the iteratorto be invalid.79 /// %Invalid constructor \& conversion. 80 81 /// Initializes the object to be invalid. 88 82 /// \sa Invalid for more details. 89 83 Node(Invalid) { } 90 84 /// Equality operator 91 85 86 /// Equality operator. 87 /// 92 88 /// Two iterators are equal if and only if they point to the 93 /// same object or both are invalid.89 /// same object or both are \c INVALID. 94 90 bool operator==(Node) const { return true; } 95 91 96 92 /// Inequality operator 97 93 98 /// \sa operator==(Node n) 99 /// 94 /// Inequality operator. 100 95 bool operator!=(Node) const { return true; } 101 96 102 97 /// Artificial ordering operator. 103 98 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. 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. 110 104 bool operator<(Node) const { return false; } 111 112 }; 113 114 /// This iterator goes through each node. 115 116 /// This iterator goes through each node. 105 }; 106 107 /// Iterator class for the nodes. 108 109 /// This iterator goes through each node of the digraph. 117 110 /// Its usage is quite simple, for example you can count the number 118 /// of nodes in digraph \c g of type \cDigraph like this:111 /// of nodes in a digraph \c g of type \c %Digraph like this: 119 112 ///\code 120 113 /// int count=0; … … 125 118 /// Default constructor 126 119 127 /// @warning The default constructor sets the iterator128 /// to an undefined value.120 /// Default constructor. 121 /// \warning It sets the iterator to an undefined value. 129 122 NodeIt() { } 130 123 /// Copy constructor. … … 133 126 /// 134 127 NodeIt(const NodeIt& n) : Node(n) { } 135 /// Invalid constructor \& conversion.136 137 /// Initialize the iterator to be invalid.128 /// %Invalid constructor \& conversion. 129 130 /// Initializes the iterator to be invalid. 138 131 /// \sa Invalid for more details. 139 132 NodeIt(Invalid) { } 140 133 /// Sets the iterator to the first node. 141 134 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. 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 /// 151 142 NodeIt(const Digraph&, const Node&) { } 152 143 /// Next node. … … 158 149 159 150 160 /// Class for identifying an arcof the digraph151 /// The arc type of the digraph 161 152 162 153 /// This class identifies an arc of the digraph. It also serves … … 167 158 /// Default constructor 168 159 169 /// @warning The default constructor sets the iterator170 /// to an undefined value.160 /// Default constructor. 161 /// \warning It sets the object to an undefined value. 171 162 Arc() { } 172 163 /// Copy constructor. … … 175 166 /// 176 167 Arc(const Arc&) { } 177 /// Initialize the iterator to be invalid.178 179 /// Initialize the iteratorto be invalid.180 /// 168 /// %Invalid constructor \& conversion. 169 170 /// Initializes the object to be invalid. 171 /// \sa Invalid for more details. 181 172 Arc(Invalid) { } 182 173 /// Equality operator 183 174 175 /// Equality operator. 176 /// 184 177 /// Two iterators are equal if and only if they point to the 185 /// same object or both are invalid.178 /// same object or both are \c INVALID. 186 179 bool operator==(Arc) const { return true; } 187 180 /// Inequality operator 188 181 189 /// \sa operator==(Arc n) 190 /// 182 /// Inequality operator. 191 183 bool operator!=(Arc) const { return true; } 192 184 193 185 /// Artificial ordering operator. 194 186 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. 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. 201 192 bool operator<(Arc) const { return false; } 202 193 }; 203 194 204 /// This iterator goes troughthe outgoing arcs of a node.195 /// Iterator class for the outgoing arcs of a node. 205 196 206 197 /// This iterator goes trough the \e outgoing arcs of a certain node … … 208 199 /// Its usage is quite simple, for example you can count the number 209 200 /// of outgoing arcs of a node \c n 210 /// in digraph \c g of type \cDigraph as follows.201 /// in a digraph \c g of type \c %Digraph as follows. 211 202 ///\code 212 203 /// int count=0; 213 /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;204 /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; 214 205 ///\endcode 215 216 206 class OutArcIt : public Arc { 217 207 public: 218 208 /// Default constructor 219 209 220 /// @warning The default constructor sets the iterator221 /// to an undefined value.210 /// Default constructor. 211 /// \warning It sets the iterator to an undefined value. 222 212 OutArcIt() { } 223 213 /// Copy constructor. … … 226 216 /// 227 217 OutArcIt(const OutArcIt& e) : Arc(e) { } 228 /// Initialize the iterator to be invalid.229 230 /// Initialize the iterator to be invalid.231 /// 218 /// %Invalid constructor \& conversion. 219 220 /// Initializes the iterator to be invalid. 221 /// \sa Invalid for more details. 232 222 OutArcIt(Invalid) { } 233 /// This constructor sets the iterator to the first outgoing arc.234 235 /// This constructor sets the iterator to the first outgoing arc of236 /// the node.223 /// Sets the iterator to the first outgoing arc. 224 225 /// Sets the iterator to the first outgoing arc of the given node. 226 /// 237 227 OutArcIt(const Digraph&, const Node&) { } 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. 228 /// Sets the iterator to the given arc. 229 230 /// Sets the iterator to the given arc of the given digraph. 231 /// 243 232 OutArcIt(const Digraph&, const Arc&) { } 244 /// Next outgoing arc233 /// Next outgoing arc 245 234 246 235 /// Assign the iterator to the next … … 249 238 }; 250 239 251 /// This iterator goes troughthe incoming arcs of a node.240 /// Iterator class for the incoming arcs of a node. 252 241 253 242 /// This iterator goes trough the \e incoming arcs of a certain node 254 243 /// of a digraph. 255 244 /// Its usage is quite simple, for example you can count the number 256 /// of outgoing arcs of a node \c n257 /// in digraph \c g of type \cDigraph as follows.245 /// of incoming arcs of a node \c n 246 /// in a digraph \c g of type \c %Digraph as follows. 258 247 ///\code 259 248 /// int count=0; 260 /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;249 /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; 261 250 ///\endcode 262 263 251 class InArcIt : public Arc { 264 252 public: 265 253 /// Default constructor 266 254 267 /// @warning The default constructor sets the iterator268 /// to an undefined value.255 /// Default constructor. 256 /// \warning It sets the iterator to an undefined value. 269 257 InArcIt() { } 270 258 /// Copy constructor. … … 273 261 /// 274 262 InArcIt(const InArcIt& e) : Arc(e) { } 275 /// Initialize the iterator to be invalid.276 277 /// Initialize the iterator to be invalid.278 /// 263 /// %Invalid constructor \& conversion. 264 265 /// Initializes the iterator to be invalid. 266 /// \sa Invalid for more details. 279 267 InArcIt(Invalid) { } 280 /// This constructor sets the iterator tofirst incoming arc.281 282 /// This constructor set the iterator to the first incoming arc of283 /// the node.268 /// Sets the iterator to the first incoming arc. 269 270 /// Sets the iterator to the first incoming arc of the given node. 271 /// 284 272 InArcIt(const Digraph&, const Node&) { } 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. 273 /// Sets the iterator to the given arc. 274 275 /// Sets the iterator to the given arc of the given digraph. 276 /// 290 277 InArcIt(const Digraph&, const Arc&) { } 291 278 /// Next incoming arc 292 279 293 /// Assign the iterator to the next inarc of the corresponding node.294 /// 280 /// Assign the iterator to the next 281 /// incoming arc of the corresponding node. 295 282 InArcIt& operator++() { return *this; } 296 283 }; 297 /// This iterator goes through each arc. 298 299 /// This iterator goes through each arc of a digraph. 284 285 /// Iterator class for the arcs. 286 287 /// This iterator goes through each arc of the digraph. 300 288 /// Its usage is quite simple, for example you can count the number 301 /// of arcs in a digraph \c g of type \c Digraph as follows:289 /// of arcs in a digraph \c g of type \c %Digraph as follows: 302 290 ///\code 303 291 /// int count=0; 304 /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;292 /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count; 305 293 ///\endcode 306 294 class ArcIt : public Arc { … … 308 296 /// Default constructor 309 297 310 /// @warning The default constructor sets the iterator311 /// to an undefined value.298 /// Default constructor. 299 /// \warning It sets the iterator to an undefined value. 312 300 ArcIt() { } 313 301 /// Copy constructor. … … 316 304 /// 317 305 ArcIt(const ArcIt& e) : Arc(e) { } 318 /// Initialize the iterator to be invalid.319 320 /// Initialize the iterator to be invalid.321 /// 306 /// %Invalid constructor \& conversion. 307 308 /// Initializes the iterator to be invalid. 309 /// \sa Invalid for more details. 322 310 ArcIt(Invalid) { } 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. 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 /// 333 320 ArcIt(const Digraph&, const Arc&) { } 334 /// Next arc321 /// Next arc 335 322 336 323 /// Assign the iterator to the next arc. 324 /// 337 325 ArcIt& operator++() { return *this; } 338 326 }; 339 ///Gives back the target node of an arc. 340 341 ///Gives back the target node of an arc. 342 /// 327 328 /// \brief The source node of the arc. 329 /// 330 /// Returns the source node of the given arc. 331 Node source(Arc) const { return INVALID; } 332 333 /// \brief The target node of the arc. 334 /// 335 /// Returns the target node of the given arc. 343 336 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 /// 348 Node source(Arc) const { return INVALID; } 349 350 /// \brief Returns the ID of the node. 337 338 /// \brief The ID of the node. 339 /// 340 /// Returns the ID of the given node. 351 341 int id(Node) const { return -1; } 352 342 353 /// \brief Returns the ID of the arc. 343 /// \brief The ID of the arc. 344 /// 345 /// Returns the ID of the given arc. 354 346 int id(Arc) const { return -1; } 355 347 356 /// \brief Returns the node with the given ID. 357 /// 358 /// \pre The argument should be a valid node ID in the graph. 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. 359 352 Node nodeFromId(int) const { return INVALID; } 360 353 361 /// \brief Returns the arc with the given ID. 362 /// 363 /// \pre The argument should be a valid arc ID in the graph. 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. 364 358 Arc arcFromId(int) const { return INVALID; } 365 359 366 /// \brief Returns an upper bound on the node IDs. 360 /// \brief An upper bound on the node IDs. 361 /// 362 /// Returns an upper bound on the node IDs. 367 363 int maxNodeId() const { return -1; } 368 364 369 /// \brief Returns an upper bound on the arc IDs. 365 /// \brief An upper bound on the arc IDs. 366 /// 367 /// Returns an upper bound on the arc IDs. 370 368 int maxArcId() const { return -1; } 371 369 … … 393 391 int maxId(Arc) const { return -1; } 394 392 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 395 398 /// \brief The base node of the iterator. 396 399 /// 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; }400 /// Returns the base node of the given outgoing arc iterator 401 /// (i.e. the source node of the corresponding arc). 402 Node baseNode(OutArcIt) const { return INVALID; } 400 403 401 404 /// \brief The running node of the iterator. 402 405 /// 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; }406 /// Returns the running node of the given outgoing arc iterator 407 /// (i.e. the target node of the corresponding arc). 408 Node runningNode(OutArcIt) const { return INVALID; } 406 409 407 410 /// \brief The base node of the iterator. 408 411 /// 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; }412 /// Returns the base node of the given incomming arc iterator 413 /// (i.e. the target node of the corresponding arc). 414 Node baseNode(InArcIt) const { return INVALID; } 412 415 413 416 /// \brief The running node of the iterator. 414 417 /// 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. 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. 427 426 template<class T> 428 427 class NodeMap : public ReferenceMap<Node, T, T&, const T&> { 429 428 public: 430 429 431 /// \e432 NodeMap(const Digraph&) { }433 /// \e430 /// Constructor 431 explicit NodeMap(const Digraph&) { } 432 /// Constructor with given initial value 434 433 NodeMap(const Digraph&, T) { } 435 434 … … 446 445 }; 447 446 448 /// \brief Reference map of the arcs to type \c T. 449 /// 450 /// Reference map of the arcs to type \c T. 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. 451 451 template<class T> 452 452 class ArcMap : public ReferenceMap<Arc, T, T&, const T&> { 453 453 public: 454 454 455 /// \e456 ArcMap(const Digraph&) { }457 /// \e455 /// Constructor 456 explicit ArcMap(const Digraph&) { } 457 /// Constructor with given initial value 458 458 ArcMap(const Digraph&, T) { } 459 459 460 private: 460 461 ///Copy constructor -
lemon/concepts/graph.h
r704 r781 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> 27 29 #include <lemon/core.h> 28 30 … … 32 34 /// \ingroup graph_concepts 33 35 /// 34 /// \brief Class describing the concept of Undirected Graphs.36 /// \brief Class describing the concept of undirected graphs. 35 37 /// 36 /// This class describes the common interface of all Undirected37 /// Graphs.38 /// This class describes the common interface of all undirected 39 /// graphs. 38 40 /// 39 /// As all concept describing classes it provides onlyinterface40 /// without any sensible implementation. So any algorithm for41 /// undirected graph should compile with this class, but it will not41 /// Like all concept classes, it only provides an interface 42 /// without any sensible implementation. So any general algorithm for 43 /// undirected graphs should compile with this class, but it will not 42 44 /// run properly, of course. 45 /// An actual graph implementation like \ref ListGraph or 46 /// \ref SmartGraph may have additional functionality. 43 47 /// 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. 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. 53 61 /// 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. 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. 61 68 /// 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. 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 68 73 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 69 81 public: 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 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 75 90 /// specializations for undirected graphs. 76 91 typedef True UndirectedTag; 77 92 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. 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. 85 98 class Node { 86 99 public: 87 100 /// Default constructor 88 101 89 /// @warning The default constructor sets the iterator90 /// to an undefined value.102 /// Default constructor. 103 /// \warning It sets the object to an undefined value. 91 104 Node() { } 92 105 /// Copy constructor. … … 96 109 Node(const Node&) { } 97 110 98 /// Invalid constructor \& conversion.99 100 /// This constructor initializes the iteratorto be invalid.111 /// %Invalid constructor \& conversion. 112 113 /// Initializes the object to be invalid. 101 114 /// \sa Invalid for more details. 102 115 Node(Invalid) { } 103 116 /// Equality operator 104 117 118 /// Equality operator. 119 /// 105 120 /// Two iterators are equal if and only if they point to the 106 /// same object or both are invalid.121 /// same object or both are \c INVALID. 107 122 bool operator==(Node) const { return true; } 108 123 109 124 /// Inequality operator 110 125 111 /// \sa operator==(Node n) 112 /// 126 /// Inequality operator. 113 127 bool operator!=(Node) const { return true; } 114 128 115 129 /// Artificial ordering operator. 116 130 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 131 /// Artificial ordering operator. 132 /// 133 /// \note This operator only has to define some strict ordering of 121 134 /// the items; this order has nothing to do with the iteration 122 135 /// ordering of the items. … … 125 138 }; 126 139 127 /// This iterator goes through each node.128 129 /// This iterator goes through each node .140 /// Iterator class for the nodes. 141 142 /// This iterator goes through each node of the graph. 130 143 /// Its usage is quite simple, for example you can count the number 131 /// of nodes in graph \c g of type \cGraph like this:144 /// of nodes in a graph \c g of type \c %Graph like this: 132 145 ///\code 133 146 /// int count=0; … … 138 151 /// Default constructor 139 152 140 /// @warning The default constructor sets the iterator141 /// to an undefined value.153 /// Default constructor. 154 /// \warning It sets the iterator to an undefined value. 142 155 NodeIt() { } 143 156 /// Copy constructor. … … 146 159 /// 147 160 NodeIt(const NodeIt& n) : Node(n) { } 148 /// Invalid constructor \& conversion.149 150 /// Initialize the iterator to be invalid.161 /// %Invalid constructor \& conversion. 162 163 /// Initializes the iterator to be invalid. 151 164 /// \sa Invalid for more details. 152 165 NodeIt(Invalid) { } 153 166 /// Sets the iterator to the first node. 154 167 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. 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 /// 164 175 NodeIt(const Graph&, const Node&) { } 165 176 /// Next node. … … 171 182 172 183 173 /// The base type of the edge iterators. 174 175 /// The base type of the edge iterators. 176 /// 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. 177 189 class Edge { 178 190 public: 179 191 /// Default constructor 180 192 181 /// @warning The default constructor sets the iterator182 /// to an undefined value.193 /// Default constructor. 194 /// \warning It sets the object to an undefined value. 183 195 Edge() { } 184 196 /// Copy constructor. … … 187 199 /// 188 200 Edge(const Edge&) { } 189 /// Initialize the iterator to be invalid.190 191 /// Initialize the iteratorto be invalid.192 /// 201 /// %Invalid constructor \& conversion. 202 203 /// Initializes the object to be invalid. 204 /// \sa Invalid for more details. 193 205 Edge(Invalid) { } 194 206 /// Equality operator 195 207 208 /// Equality operator. 209 /// 196 210 /// Two iterators are equal if and only if they point to the 197 /// same object or both are invalid.211 /// same object or both are \c INVALID. 198 212 bool operator==(Edge) const { return true; } 199 213 /// Inequality operator 200 214 201 /// \sa operator==(Edge n) 202 /// 215 /// Inequality operator. 203 216 bool operator!=(Edge) const { return true; } 204 217 205 218 /// Artificial ordering operator. 206 219 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. 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. 213 225 bool operator<(Edge) const { return false; } 214 226 }; 215 227 216 /// This iterator goes through each edge.217 218 /// This iterator goes through each edge of agraph.228 /// Iterator class for the edges. 229 230 /// This iterator goes through each edge of the graph. 219 231 /// Its usage is quite simple, for example you can count the number 220 /// of edges in a graph \c g of type \c Graph as follows:232 /// of edges in a graph \c g of type \c %Graph as follows: 221 233 ///\code 222 234 /// int count=0; … … 227 239 /// Default constructor 228 240 229 /// @warning The default constructor sets the iterator230 /// to an undefined value.241 /// Default constructor. 242 /// \warning It sets the iterator to an undefined value. 231 243 EdgeIt() { } 232 244 /// Copy constructor. … … 235 247 /// 236 248 EdgeIt(const EdgeIt& e) : Edge(e) { } 237 /// Initialize the iterator to be invalid.238 239 /// Initialize the iterator to be invalid.240 /// 249 /// %Invalid constructor \& conversion. 250 251 /// Initializes the iterator to be invalid. 252 /// \sa Invalid for more details. 241 253 EdgeIt(Invalid) { } 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. 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 /// 252 263 EdgeIt(const Graph&, const Edge&) { } 253 264 /// Next edge 254 265 255 266 /// Assign the iterator to the next edge. 267 /// 256 268 EdgeIt& operator++() { return *this; } 257 269 }; 258 270 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 /// 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. 266 275 /// Its usage is quite simple, for example you can compute the 267 /// degree (i.e. count the number of incident arcsof a node \c n268 /// in graph \c g of type \cGraph as follows.276 /// degree (i.e. the number of incident edges) of a node \c n 277 /// in a graph \c g of type \c %Graph as follows. 269 278 /// 270 279 ///\code … … 272 281 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; 273 282 ///\endcode 283 /// 284 /// \warning Loop edges will be iterated twice. 274 285 class IncEdgeIt : public Edge { 275 286 public: 276 287 /// Default constructor 277 288 278 /// @warning The default constructor sets the iterator279 /// to an undefined value.289 /// Default constructor. 290 /// \warning It sets the iterator to an undefined value. 280 291 IncEdgeIt() { } 281 292 /// Copy constructor. … … 284 295 /// 285 296 IncEdgeIt(const IncEdgeIt& e) : Edge(e) { } 286 /// Initialize the iterator to be invalid.287 288 /// Initialize the iterator to be invalid.289 /// 297 /// %Invalid constructor \& conversion. 298 299 /// Initializes the iterator to be invalid. 300 /// \sa Invalid for more details. 290 301 IncEdgeIt(Invalid) { } 291 /// This constructor sets the iterator to first incident arc.292 293 /// This constructor set the iterator to the first incident arc of294 /// the node.302 /// Sets the iterator to the first incident edge. 303 304 /// Sets the iterator to the first incident edge of the given node. 305 /// 295 306 IncEdgeIt(const Graph&, const Node&) { } 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. 307 /// Sets the iterator to the given edge. 308 309 /// Sets the iterator to the given edge of the given graph. 310 /// 301 311 IncEdgeIt(const Graph&, const Edge&) { } 302 /// Next incident arc303 304 /// Assign the iterator to the next incident arc312 /// Next incident edge 313 314 /// Assign the iterator to the next incident edge 305 315 /// of the corresponding node. 306 316 IncEdgeIt& operator++() { return *this; } 307 317 }; 308 318 309 /// The directed arc type.310 311 /// Th e directed arc type. It can be converted to the312 /// edge or it should be inherited from the undirected313 /// edge.319 /// The arc type of the graph 320 321 /// This class identifies a directed arc of the graph. It also serves 322 /// as a base class of the arc iterators, 323 /// thus they will convert to this type. 314 324 class Arc { 315 325 public: 316 326 /// Default constructor 317 327 318 /// @warning The default constructor sets the iterator319 /// to an undefined value.328 /// Default constructor. 329 /// \warning It sets the object to an undefined value. 320 330 Arc() { } 321 331 /// Copy constructor. … … 324 334 /// 325 335 Arc(const Arc&) { } 326 /// Initialize the iterator to be invalid.327 328 /// Initialize the iteratorto be invalid.329 /// 336 /// %Invalid constructor \& conversion. 337 338 /// Initializes the object to be invalid. 339 /// \sa Invalid for more details. 330 340 Arc(Invalid) { } 331 341 /// Equality operator 332 342 343 /// Equality operator. 344 /// 333 345 /// Two iterators are equal if and only if they point to the 334 /// same object or both are invalid.346 /// same object or both are \c INVALID. 335 347 bool operator==(Arc) const { return true; } 336 348 /// Inequality operator 337 349 338 /// \sa operator==(Arc n) 339 /// 350 /// Inequality operator. 340 351 bool operator!=(Arc) const { return true; } 341 352 342 353 /// Artificial ordering operator. 343 354 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. 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. 350 360 bool operator<(Arc) const { return false; } 351 361 352 /// Converison to Edge 362 /// Converison to \c Edge 363 364 /// Converison to \c Edge. 365 /// 353 366 operator Edge() const { return Edge(); } 354 367 }; 355 /// This iterator goes through each directed arc. 356 357 /// This iterator goes through each arc of a graph. 368 369 /// Iterator class for the arcs. 370 371 /// This iterator goes through each directed arc of the graph. 358 372 /// Its usage is quite simple, for example you can count the number 359 /// of arcs in a graph \c g of type \c Graph as follows:373 /// of arcs in a graph \c g of type \c %Graph as follows: 360 374 ///\code 361 375 /// int count=0; 362 /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;376 /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count; 363 377 ///\endcode 364 378 class ArcIt : public Arc { … … 366 380 /// Default constructor 367 381 368 /// @warning The default constructor sets the iterator369 /// to an undefined value.382 /// Default constructor. 383 /// \warning It sets the iterator to an undefined value. 370 384 ArcIt() { } 371 385 /// Copy constructor. … … 374 388 /// 375 389 ArcIt(const ArcIt& e) : Arc(e) { } 376 /// Initialize the iterator to be invalid.377 378 /// Initialize the iterator to be invalid.379 /// 390 /// %Invalid constructor \& conversion. 391 392 /// Initializes the iterator to be invalid. 393 /// \sa Invalid for more details. 380 394 ArcIt(Invalid) { } 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. 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 /// 391 404 ArcIt(const Graph&, const Arc&) { } 392 /// Next arc405 /// Next arc 393 406 394 407 /// Assign the iterator to the next arc. 408 /// 395 409 ArcIt& operator++() { return *this; } 396 410 }; 397 411 398 /// This iterator goes trough the outgoing directedarcs of a node.399 400 /// This iterator goes trough the \e outgoing arcs of a certain node401 /// of a graph.412 /// Iterator class for the outgoing arcs of a node. 413 414 /// This iterator goes trough the \e outgoing directed arcs of a 415 /// certain node of a graph. 402 416 /// Its usage is quite simple, for example you can count the number 403 417 /// of outgoing arcs of a node \c n 404 /// in graph \c g of type \cGraph as follows.418 /// in a graph \c g of type \c %Graph as follows. 405 419 ///\code 406 420 /// int count=0; 407 /// for ( Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;421 /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count; 408 422 ///\endcode 409 410 423 class OutArcIt : public Arc { 411 424 public: 412 425 /// Default constructor 413 426 414 /// @warning The default constructor sets the iterator415 /// to an undefined value.427 /// Default constructor. 428 /// \warning It sets the iterator to an undefined value. 416 429 OutArcIt() { } 417 430 /// Copy constructor. … … 420 433 /// 421 434 OutArcIt(const OutArcIt& e) : Arc(e) { } 422 /// Initialize the iterator to be invalid.423 424 /// Initialize the iterator to be invalid.425 /// 435 /// %Invalid constructor \& conversion. 436 437 /// Initializes the iterator to be invalid. 438 /// \sa Invalid for more details. 426 439 OutArcIt(Invalid) { } 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 440 /// Sets the iterator to the first outgoing arc. 441 442 /// Sets the iterator to the first outgoing arc of the given node. 443 /// 433 444 OutArcIt(const Graph& n, const Node& g) { 434 445 ignore_unused_variable_warning(n); 435 446 ignore_unused_variable_warning(g); 436 447 } 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. 448 /// Sets the iterator to the given arc. 449 450 /// Sets the iterator to the given arc of the given graph. 451 /// 442 452 OutArcIt(const Graph&, const Arc&) { } 443 /// Next outgoing arc453 /// Next outgoing arc 444 454 445 455 /// Assign the iterator to the next … … 448 458 }; 449 459 450 /// This iterator goes trough the incoming directedarcs of a node.451 452 /// This iterator goes trough the \e incoming arcs of a certain node453 /// of a graph.460 /// Iterator class for the incoming arcs of a node. 461 462 /// This iterator goes trough the \e incoming directed arcs of a 463 /// certain node of a graph. 454 464 /// Its usage is quite simple, for example you can count the number 455 /// of outgoing arcs of a node \c n456 /// in graph \c g of type \cGraph as follows.465 /// of incoming arcs of a node \c n 466 /// in a graph \c g of type \c %Graph as follows. 457 467 ///\code 458 468 /// int count=0; 459 /// for (Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;469 /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count; 460 470 ///\endcode 461 462 471 class InArcIt : public Arc { 463 472 public: 464 473 /// Default constructor 465 474 466 /// @warning The default constructor sets the iterator467 /// to an undefined value.475 /// Default constructor. 476 /// \warning It sets the iterator to an undefined value. 468 477 InArcIt() { } 469 478 /// Copy constructor. … … 472 481 /// 473 482 InArcIt(const InArcIt& e) : Arc(e) { } 474 /// Initialize the iterator to be invalid.475 476 /// Initialize the iterator to be invalid.477 /// 483 /// %Invalid constructor \& conversion. 484 485 /// Initializes the iterator to be invalid. 486 /// \sa Invalid for more details. 478 487 InArcIt(Invalid) { } 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 488 /// Sets the iterator to the first incoming arc. 489 490 /// Sets the iterator to the first incoming arc of the given node. 491 /// 485 492 InArcIt(const Graph& g, const Node& n) { 486 493 ignore_unused_variable_warning(n); 487 494 ignore_unused_variable_warning(g); 488 495 } 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. 496 /// Sets the iterator to the given arc. 497 498 /// Sets the iterator to the given arc of the given graph. 499 /// 494 500 InArcIt(const Graph&, const Arc&) { } 495 501 /// Next incoming arc 496 502 497 /// Assign the iterator to the next inarc of the corresponding node.498 /// 503 /// Assign the iterator to the next 504 /// incoming arc of the corresponding node. 499 505 InArcIt& operator++() { return *this; } 500 506 }; 501 507 502 /// \brief Reference map of the nodes to type \c T. 503 /// 504 /// Reference map of the nodes to type \c T. 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. 505 512 template<class T> 506 513 class NodeMap : public ReferenceMap<Node, T, T&, const T&> … … 508 515 public: 509 516 510 /// \e511 NodeMap(const Graph&) { }512 /// \e517 /// Constructor 518 explicit NodeMap(const Graph&) { } 519 /// Constructor with given initial value 513 520 NodeMap(const Graph&, T) { } 514 521 … … 525 532 }; 526 533 527 /// \brief Reference map of the arcs to type \c T. 528 /// 529 /// Reference map of the arcs to type \c T. 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. 530 538 template<class T> 531 539 class ArcMap : public ReferenceMap<Arc, T, T&, const T&> … … 533 541 public: 534 542 535 /// \e536 ArcMap(const Graph&) { }537 /// \e543 /// Constructor 544 explicit ArcMap(const Graph&) { } 545 /// Constructor with given initial value 538 546 ArcMap(const Graph&, T) { } 547 539 548 private: 540 549 ///Copy constructor … … 549 558 }; 550 559 551 /// Reference map of the edges to type \c T. 552 553 /// Reference map of the edges to type \c T. 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. 554 564 template<class T> 555 565 class EdgeMap : public ReferenceMap<Edge, T, T&, const T&> … … 557 567 public: 558 568 559 /// \e560 EdgeMap(const Graph&) { }561 /// \e569 /// Constructor 570 explicit EdgeMap(const Graph&) { } 571 /// Constructor with given initial value 562 572 EdgeMap(const Graph&, T) { } 573 563 574 private: 564 575 ///Copy constructor … … 573 584 }; 574 585 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. 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. 619 595 /// \sa v() 620 596 /// \sa direction() 621 597 Node u(Edge) const { return INVALID; } 622 598 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. 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. 633 608 /// \sa u() 634 609 /// \sa direction() 635 610 Node v(Edge) const { return INVALID; } 636 611 637 /// \brief Source node of the directed arc. 612 /// \brief The source node of the arc. 613 /// 614 /// Returns the source node of the given arc. 638 615 Node source(Arc) const { return INVALID; } 639 616 640 /// \brief Target node of the directed arc. 617 /// \brief The target node of the arc. 618 /// 619 /// Returns the target node of the given arc. 641 620 Node target(Arc) const { return INVALID; } 642 621 643 /// \brief Returns the id of the node. 622 /// \brief The ID of the node. 623 /// 624 /// Returns the ID of the given node. 644 625 int id(Node) const { return -1; } 645 626 646 /// \brief Returns the id of the edge. 627 /// \brief The ID of the edge. 628 /// 629 /// Returns the ID of the given edge. 647 630 int id(Edge) const { return -1; } 648 631 649 /// \brief Returns the id of the arc. 632 /// \brief The ID of the arc. 633 /// 634 /// Returns the ID of the given arc. 650 635 int id(Arc) const { return -1; } 651 636 652 /// \brief Returns the node with the given id. 653 /// 654 /// \pre The argument should be a valid node id in the graph. 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. 655 641 Node nodeFromId(int) const { return INVALID; } 656 642 657 /// \brief Returns the edge with the given id. 658 /// 659 /// \pre The argument should be a valid edge id in the graph. 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. 660 647 Edge edgeFromId(int) const { return INVALID; } 661 648 662 /// \brief Returns the arc with the given id. 663 /// 664 /// \pre The argument should be a valid arc id in the graph. 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. 665 653 Arc arcFromId(int) const { return INVALID; } 666 654 667 /// \brief Returns an upper bound on the node IDs. 655 /// \brief An upper bound on the node IDs. 656 /// 657 /// Returns an upper bound on the node IDs. 668 658 int maxNodeId() const { return -1; } 669 659 670 /// \brief Returns an upper bound on the edge IDs. 660 /// \brief An upper bound on the edge IDs. 661 /// 662 /// Returns an upper bound on the edge IDs. 671 663 int maxEdgeId() const { return -1; } 672 664 673 /// \brief Returns an upper bound on the arc IDs. 665 /// \brief An upper bound on the arc IDs. 666 /// 667 /// Returns an upper bound on the arc IDs. 674 668 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 as 673 /// 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 arc 679 /// represents the given edge and its direction comes 680 /// from the bool parameter. If it is \c true, then the direction 681 /// 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 given 689 /// 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; } 675 703 676 704 void first(Node&) const {} … … 706 734 int maxId(Arc) const { return -1; } 707 735 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 } 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; } 749 769 750 770 template <typename _Graph> -
lemon/concepts/graph_components.h
r713 r781 93 93 /// associative containers (e.g. \c std::map). 94 94 /// 95 /// \note This operator only ha veto define some strict ordering of95 /// \note This operator only has 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
r631 r757 17 17 */ 18 18 19 #ifndef LEMON_CONCEPTS_HEAP_H 20 #define LEMON_CONCEPTS_HEAP_H 21 19 22 ///\ingroup concept 20 23 ///\file 21 24 ///\brief The concept of heaps. 22 25 23 #ifndef LEMON_CONCEPTS_HEAP_H24 #define LEMON_CONCEPTS_HEAP_H25 26 26 #include <lemon/core.h> 27 27 #include <lemon/concept_check.h> … … 36 36 /// \brief The heap concept. 37 37 /// 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. 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. 43 45 /// 44 /// \tparam PR Type of the priority of the items. 45 /// \tparam IM A read and writable item map with int values, used 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 46 52 /// internally to handle the cross references. 47 /// \tparam C omp A functor class for the ordering ofthe priorities.53 /// \tparam CMP A functor class for comparing the priorities. 48 54 /// The default is \c std::less<PR>. 49 55 #ifdef DOXYGEN 50 template <typename PR, typename IM, typename C omp = std::less<PR>>56 template <typename PR, typename IM, typename CMP> 51 57 #else 52 template <typename PR, typename IM >58 template <typename PR, typename IM, typename CMP = std::less<PR> > 53 59 #endif 54 60 class Heap { … … 65 71 /// 66 72 /// Each item has a state associated to it. It can be "in heap", 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. 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. 70 75 /// 71 76 /// The item-int map must be initialized in such way that it assigns … … 73 78 enum State { 74 79 IN_HEAP = 0, ///< = 0. The "in heap" state constant. 75 PRE_HEAP = -1, ///< = -1. The "pre 76 POST_HEAP = -2 ///< = -2. The "post 80 PRE_HEAP = -1, ///< = -1. The "pre-heap" state constant. 81 POST_HEAP = -2 ///< = -2. The "post-heap" state constant. 77 82 }; 78 83 79 /// \brief The constructor.80 /// 81 /// The constructor.84 /// \brief Constructor. 85 /// 86 /// Constructor. 82 87 /// \param map A map that assigns \c int values to keys of type 83 88 /// \c Item. It is used internally by the heap implementations to 84 89 /// handle the cross references. The assigned value must be 85 /// \c PRE_HEAP (<tt>-1</tt>) for e veryitem.90 /// \c PRE_HEAP (<tt>-1</tt>) for each item. 86 91 explicit Heap(ItemIntMap &map) {} 87 92 93 /// \brief Constructor. 94 /// 95 /// Constructor. 96 /// \param map A map that assigns \c int values to keys of type 97 /// \c Item. It is used internally by the heap implementations to 98 /// handle the cross references. The assigned value must be 99 /// \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 88 103 /// \brief The number of items stored in the heap. 89 104 /// 90 /// Returns the number of items stored in the heap.105 /// This function returns the number of items stored in the heap. 91 106 int size() const { return 0; } 92 107 93 /// \brief Check sif the heap is empty.94 /// 95 /// Returns \c true if the heap is empty.108 /// \brief Check if the heap is empty. 109 /// 110 /// This function returns \c true if the heap is empty. 96 111 bool empty() const { return false; } 97 112 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. 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. 106 126 /// \param i The item to insert. 107 127 /// \param p The priority of the item. 128 /// \pre \e i must not be stored in the heap. 108 129 void push(const Item &i, const Prio &p) {} 109 130 110 /// \brief Return sthe item having minimum priority.111 /// 112 /// Returns the item having minimum priority.131 /// \brief Return the item having minimum priority. 132 /// 133 /// This function returns the item having minimum priority. 113 134 /// \pre The heap must be non-empty. 114 135 Item top() const {} … … 116 137 /// \brief The minimum priority. 117 138 /// 118 /// Returns the minimum priority.139 /// This function returns the minimum priority. 119 140 /// \pre The heap must be non-empty. 120 141 Prio prio() const {} 121 142 122 /// \brief Remove sthe item having minimum priority.123 /// 124 /// Removes the item having minimum priority.143 /// \brief Remove the item having minimum priority. 144 /// 145 /// This function removes the item having minimum priority. 125 146 /// \pre The heap must be non-empty. 126 147 void pop() {} 127 148 128 /// \brief Removes an item from the heap. 129 /// 130 /// Removes the given item from the heap if it is already stored. 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. 131 153 /// \param i The item to delete. 154 /// \pre \e i must be in the heap. 132 155 void erase(const Item &i) {} 133 156 134 /// \brief The priority of an item.135 /// 136 /// Returns the priority of the given item.137 /// \param i The item. 138 /// \pre \ ci must be in the heap.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 \e i must be in the heap. 139 162 Prio operator[](const Item &i) const {} 140 163 141 /// \brief Set s the priority of an item or insertsit, if it is164 /// \brief Set the priority of an item or insert it, if it is 142 165 /// not stored in the heap. 143 166 /// 144 167 /// This method sets the priority of the given item if it is 145 /// already stored in the heap. 146 /// Otherwise it inserts the given itemwith the given priority.168 /// already stored in the heap. Otherwise it inserts the given 169 /// item into the heap with the given priority. 147 170 /// 148 171 /// \param i The item. … … 150 173 void set(const Item &i, const Prio &p) {} 151 174 152 /// \brief Decrease sthe priority of an item to the given value.153 /// 154 /// Decreases the priority of an item to the given value.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. 155 178 /// \param i The item. 156 179 /// \param p The priority. 157 /// \pre \ c i must be stored in the heap with priority at least \cp.180 /// \pre \e i must be stored in the heap with priority at least \e p. 158 181 void decrease(const Item &i, const Prio &p) {} 159 182 160 /// \brief Increase sthe priority of an item to the given value.161 /// 162 /// Increases the priority of an item to the given value.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. 163 186 /// \param i The item. 164 187 /// \param p The priority. 165 /// \pre \ c i must be stored in the heap with priority at most \cp.188 /// \pre \e i must be stored in the heap with priority at most \e p. 166 189 void increase(const Item &i, const Prio &p) {} 167 190 168 /// \brief Returns if an item is in, has already been in, or has 169 /// never been in the heap. 191 /// \brief Return the state of an item. 170 192 /// 171 193 /// This method returns \c PRE_HEAP if the given item has never … … 177 199 State state(const Item &i) const {} 178 200 179 /// \brief Set sthe state of an item in the heap.180 /// 181 /// Sets the state of the given item in the heap. It can be used182 /// to manually clear the heap when it is important to achive the183 /// better time complexity.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 important 205 /// to achive better time complexity. 184 206 /// \param i The item. 185 207 /// \param st The state. It should not be \c IN_HEAP. -
lemon/concepts/maps.h
r576 r765 183 183 template<typename _ReferenceMap> 184 184 struct Constraints { 185 void constraints() { 185 typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type 186 constraints() { 186 187 checkConcept<ReadWriteMap<K, T>, _ReferenceMap >(); 187 188 ref = m[key]; -
lemon/cplex.cc
r623 r793 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 } 114 147 115 148 void CplexBase::_eraseCol(int i) { -
lemon/cplex.h
r623 r793 94 94 virtual int _addCol(); 95 95 virtual int _addRow(); 96 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); 96 97 97 98 virtual void _eraseCol(int i); -
lemon/dfs.h
r631 r764 48 48 ///The type of the map that stores the predecessor 49 49 ///arcs of the %DFS paths. 50 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.50 ///It must conform to 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 meet the \ref concepts::WriteMap "WriteMap" concept. 65 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 66 ///By default it is a NullMap. 66 67 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; 67 68 ///Instantiates a \c ProcessedMap. … … 82 83 83 84 ///The type of the map that indicates which nodes are reached. 84 ///It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.85 ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 85 86 typedef typename Digraph::template NodeMap<bool> ReachedMap; 86 87 ///Instantiates a \c ReachedMap. … … 97 98 98 99 ///The type of the map that stores the distances of the nodes. 99 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.100 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 100 101 typedef typename Digraph::template NodeMap<int> DistMap; 101 102 ///Instantiates a \c DistMap. … … 225 226 ///\ref named-templ-param "Named parameter" for setting 226 227 ///\c PredMap type. 227 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.228 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 228 229 template <class T> 229 230 struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > { … … 245 246 ///\ref named-templ-param "Named parameter" for setting 246 247 ///\c DistMap type. 247 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.248 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 248 249 template <class T> 249 250 struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > { … … 265 266 ///\ref named-templ-param "Named parameter" for setting 266 267 ///\c ReachedMap type. 267 ///It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.268 ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 268 269 template <class T> 269 270 struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > { … … 285 286 ///\ref named-templ-param "Named parameter" for setting 286 287 ///\c ProcessedMap type. 287 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.288 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 288 289 template <class T> 289 290 struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > { … … 412 413 ///The simplest way to execute the DFS algorithm is to use one of the 413 414 ///member functions called \ref run(Node) "run()".\n 414 ///If you need more control on the execution, firstyou have to call415 ///\ref init() , then you can add a source node with \ref addSource()415 ///If you need better control on the execution, you have to call 416 ///\ref init() first, then you can add a source node with \ref addSource() 416 417 ///and perform the actual computation with \ref start(). 417 418 ///This procedure can be repeated if there are nodes that have not … … 670 671 ///@{ 671 672 672 ///The DFS path to anode.673 674 ///Returns the DFS path to a node.673 ///The DFS path to the given node. 674 675 ///Returns the DFS path to the given node from the root(s). 675 676 /// 676 677 ///\warning \c t should be reached from the root(s). … … 680 681 Path path(Node t) const { return Path(*G, *_pred, t); } 681 682 682 ///The distance of anode from the root(s).683 684 ///Returns the distance of anode from the root(s).683 ///The distance of the given node from the root(s). 684 685 ///Returns the distance of the given node from the root(s). 685 686 /// 686 687 ///\warning If node \c v is not reached from the root(s), then … … 691 692 int dist(Node v) const { return (*_dist)[v]; } 692 693 693 ///Returns the 'previous arc' of the %DFS tree for anode.694 ///Returns the 'previous arc' of the %DFS tree for the given node. 694 695 695 696 ///This function returns the 'previous arc' of the %DFS tree for the … … 699 700 /// 700 701 ///The %DFS tree used here is equal to the %DFS tree used in 701 ///\ref predNode() .702 ///\ref predNode() and \ref predMap(). 702 703 /// 703 704 ///\pre Either \ref run(Node) "run()" or \ref init() … … 705 706 Arc predArc(Node v) const { return (*_pred)[v];} 706 707 707 ///Returns the 'previous node' of the %DFS tree .708 ///Returns the 'previous node' of the %DFS tree for the given node. 708 709 709 710 ///This function returns the 'previous node' of the %DFS 710 711 ///tree for the node \c v, i.e. it returns the last but one node 711 /// froma %DFS path from a root to \c v. It is \c INVALID712 ///of a %DFS path from a root to \c v. It is \c INVALID 712 713 ///if \c v is not reached from the root(s) or if \c v is a root. 713 714 /// 714 715 ///The %DFS tree used here is equal to the %DFS tree used in 715 ///\ref predArc() .716 ///\ref predArc() and \ref predMap(). 716 717 /// 717 718 ///\pre Either \ref run(Node) "run()" or \ref init() … … 734 735 /// 735 736 ///Returns a const reference to the node map that stores the predecessor 736 ///arcs, which form the DFS tree .737 ///arcs, which form the DFS tree (forest). 737 738 /// 738 739 ///\pre Either \ref run(Node) "run()" or \ref init() … … 740 741 const PredMap &predMap() const { return *_pred;} 741 742 742 ///Checks if anode is reached from the root(s).743 ///Checks if the given node. node is reached from the root(s). 743 744 744 745 ///Returns \c true if \c v is reached from the root(s). … … 766 767 ///The type of the map that stores the predecessor 767 768 ///arcs of the %DFS paths. 768 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.769 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 769 770 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 770 771 ///Instantiates a PredMap. … … 781 782 782 783 ///The type of the map that indicates which nodes are processed. 783 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.784 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 784 785 ///By default it is a NullMap. 785 786 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 801 802 802 803 ///The type of the map that indicates which nodes are reached. 803 ///It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.804 ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 804 805 typedef typename Digraph::template NodeMap<bool> ReachedMap; 805 806 ///Instantiates a ReachedMap. … … 816 817 817 818 ///The type of the map that stores the distances of the nodes. 818 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.819 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 819 820 typedef typename Digraph::template NodeMap<int> DistMap; 820 821 ///Instantiates a DistMap. … … 831 832 832 833 ///The type of the DFS paths. 833 ///It must meetthe \ref concepts::Path "Path" concept.834 ///It must conform to the \ref concepts::Path "Path" concept. 834 835 typedef lemon::Path<Digraph> Path; 835 836 }; … … 837 838 /// Default traits class used by DfsWizard 838 839 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. 840 /// Default traits class used by DfsWizard. 841 /// \tparam GR The type of the digraph. 845 842 template<class GR> 846 843 class DfsWizardBase : public DfsWizardDefaultTraits<GR> … … 870 867 /// Constructor. 871 868 872 /// This constructor does not require parameters, thereforeit initiates869 /// This constructor does not require parameters, it initiates 873 870 /// all of the attributes to \c 0. 874 871 DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0), … … 900 897 typedef TR Base; 901 898 902 ///The type of the digraph the algorithm runs on.903 899 typedef typename TR::Digraph Digraph; 904 900 … … 908 904 typedef typename Digraph::OutArcIt OutArcIt; 909 905 910 ///\brief The type of the map that stores the predecessor911 ///arcs of the DFS paths.912 906 typedef typename TR::PredMap PredMap; 913 ///\brief The type of the map that stores the distances of the nodes.914 907 typedef typename TR::DistMap DistMap; 915 ///\brief The type of the map that indicates which nodes are reached.916 908 typedef typename TR::ReachedMap ReachedMap; 917 ///\brief The type of the map that indicates which nodes are processed.918 909 typedef typename TR::ProcessedMap ProcessedMap; 919 ///The type of the DFS paths920 910 typedef typename TR::Path Path; 921 911 … … 1000 990 SetPredMapBase(const TR &b) : TR(b) {} 1001 991 }; 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. 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. 1007 998 template<class T> 1008 999 DfsWizard<SetPredMapBase<T> > predMap(const T &t) … … 1018 1009 SetReachedMapBase(const TR &b) : TR(b) {} 1019 1010 }; 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. 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. 1025 1017 template<class T> 1026 1018 DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t) … … 1036 1028 SetDistMapBase(const TR &b) : TR(b) {} 1037 1029 }; 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. 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. 1043 1037 template<class T> 1044 1038 DfsWizard<SetDistMapBase<T> > distMap(const T &t) … … 1054 1048 SetProcessedMapBase(const TR &b) : TR(b) {} 1055 1049 }; 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. 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. 1061 1056 template<class T> 1062 1057 DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1209 1204 /// 1210 1205 /// The type of the map that indicates which nodes are reached. 1211 /// It must meetthe \ref concepts::ReadWriteMap "ReadWriteMap" concept.1206 /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 1212 1207 typedef typename Digraph::template NodeMap<bool> ReachedMap; 1213 1208 … … 1370 1365 /// The simplest way to execute the DFS algorithm is to use one of the 1371 1366 /// member functions called \ref run(Node) "run()".\n 1372 /// If you need more control on the execution, firstyou have to call1373 /// \ref init() , then you can add a source node with \ref addSource()1367 /// If you need better control on the execution, you have to call 1368 /// \ref init() first, then you can add a source node with \ref addSource() 1374 1369 /// and perform the actual computation with \ref start(). 1375 1370 /// This procedure can be repeated if there are nodes that have not … … 1621 1616 ///@{ 1622 1617 1623 /// \brief Checks if anode is reached from the root(s).1618 /// \brief Checks if the given node is reached from the root(s). 1624 1619 /// 1625 1620 /// Returns \c true if \c v is reached from the root(s). -
lemon/dijkstra.h
r631 r764 71 71 72 72 ///The type of the map that stores the arc lengths. 73 ///It must meetthe \ref concepts::ReadMap "ReadMap" concept.73 ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. 74 74 typedef LEN LengthMap; 75 ///The type of the length of the arcs.75 ///The type of the arc lengths. 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 meetthe \ref concepts::WriteMap "WriteMap" concept.119 ///It must conform to 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 meetthe \ref concepts::WriteMap "WriteMap" concept.134 ///It must conform to 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 meetthe \ref concepts::WriteMap "WriteMap" concept.154 ///It must conform to 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 problem 173 ///when all arc lengths are non-negative. If there are negative lengths, 174 ///the BellmanFord algorithm should be used instead. 171 175 /// 172 176 ///The arc lengths are passed to the algorithm using a … … 202 206 typedef typename TR::Digraph Digraph; 203 207 204 ///The type of the length of the arcs.208 ///The type of the arc lengths. 205 209 typedef typename TR::LengthMap::Value Value; 206 210 ///The type of the map that stores the arc lengths. … … 305 309 ///\ref named-templ-param "Named parameter" for setting 306 310 ///\c PredMap type. 307 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.311 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 308 312 template <class T> 309 313 struct SetPredMap … … 326 330 ///\ref named-templ-param "Named parameter" for setting 327 331 ///\c DistMap type. 328 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.332 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 329 333 template <class T> 330 334 struct SetDistMap … … 347 351 ///\ref named-templ-param "Named parameter" for setting 348 352 ///\c ProcessedMap type. 349 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.353 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 350 354 template <class T> 351 355 struct SetProcessedMap … … 444 448 ///\ref named-templ-param "Named parameter" for setting 445 449 ///\c OperationTraits type. 450 /// For more information see \ref DijkstraDefaultOperationTraits. 446 451 template <class T> 447 452 struct SetOperationTraits … … 585 590 ///The simplest way to execute the %Dijkstra algorithm is to use 586 591 ///one of the member functions called \ref run(Node) "run()".\n 587 ///If you need more control on the execution, firstyou have to call588 ///\ref init() , then you can add several source nodes with592 ///If you need better control on the execution, you have to call 593 ///\ref init() first, then you can add several source nodes with 589 594 ///\ref addSource(). Finally the actual path computation can be 590 595 ///performed with one of the \ref start() functions. … … 802 807 ///The results of the %Dijkstra algorithm can be obtained using these 803 808 ///functions.\n 804 ///Either \ref run(Node) "run()" or \ref start() should be called809 ///Either \ref run(Node) "run()" or \ref init() should be called 805 810 ///before using them. 806 811 807 812 ///@{ 808 813 809 ///The shortest path to anode.810 811 ///Returns the shortest path to a node.814 ///The shortest path to the given node. 815 816 ///Returns the shortest path to the given node from the root(s). 812 817 /// 813 818 ///\warning \c t should be reached from the root(s). … … 817 822 Path path(Node t) const { return Path(*G, *_pred, t); } 818 823 819 ///The distance of anode from the root(s).820 821 ///Returns the distance of anode from the root(s).824 ///The distance of the given node from the root(s). 825 826 ///Returns the distance of the given node from the root(s). 822 827 /// 823 828 ///\warning If node \c v is not reached from the root(s), then … … 828 833 Value dist(Node v) const { return (*_dist)[v]; } 829 834 830 ///Returns the 'previous arc' of the shortest path tree for a node. 831 835 ///\brief Returns the 'previous arc' of the shortest path tree for 836 ///the given node. 837 /// 832 838 ///This function returns the 'previous arc' of the shortest path 833 839 ///tree for the node \c v, i.e. it returns the last arc of a … … 836 842 /// 837 843 ///The shortest path tree used here is equal to the shortest path 838 ///tree used in \ref predNode() .844 ///tree used in \ref predNode() and \ref predMap(). 839 845 /// 840 846 ///\pre Either \ref run(Node) "run()" or \ref init() … … 842 848 Arc predArc(Node v) const { return (*_pred)[v]; } 843 849 844 ///Returns the 'previous node' of the shortest path tree for a node. 845 850 ///\brief Returns the 'previous node' of the shortest path tree for 851 ///the given node. 852 /// 846 853 ///This function returns the 'previous node' of the shortest path 847 854 ///tree for the node \c v, i.e. it returns the last but one node 848 /// froma shortest path from a root to \c v. It is \c INVALID855 ///of a shortest path from a root to \c v. It is \c INVALID 849 856 ///if \c v is not reached from the root(s) or if \c v is a root. 850 857 /// 851 858 ///The shortest path tree used here is equal to the shortest path 852 ///tree used in \ref predArc() .859 ///tree used in \ref predArc() and \ref predMap(). 853 860 /// 854 861 ///\pre Either \ref run(Node) "run()" or \ref init() … … 871 878 /// 872 879 ///Returns a const reference to the node map that stores the predecessor 873 ///arcs, which form the shortest path tree .880 ///arcs, which form the shortest path tree (forest). 874 881 /// 875 882 ///\pre Either \ref run(Node) "run()" or \ref init() … … 877 884 const PredMap &predMap() const { return *_pred;} 878 885 879 ///Checks if anode is reached from the root(s).886 ///Checks if the given node is reached from the root(s). 880 887 881 888 ///Returns \c true if \c v is reached from the root(s). … … 896 903 Heap::POST_HEAP; } 897 904 898 ///The current distance of anode from the root(s).899 900 ///Returns the current distance of anode from the root(s).905 ///The current distance of the given node from the root(s). 906 907 ///Returns the current distance of the given node from the root(s). 901 908 ///It may be decreased in the following processes. 902 909 /// … … 925 932 926 933 ///The type of the map that stores the arc lengths. 927 ///It must meetthe \ref concepts::ReadMap "ReadMap" concept.934 ///It must conform to the \ref concepts::ReadMap "ReadMap" concept. 928 935 typedef LEN LengthMap; 929 ///The type of the length of the arcs.936 ///The type of the arc lengths. 930 937 typedef typename LEN::Value Value; 931 938 … … 974 981 ///The type of the map that stores the predecessor 975 982 ///arcs of the shortest paths. 976 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.983 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 977 984 typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap; 978 985 ///Instantiates a PredMap. … … 989 996 990 997 ///The type of the map that indicates which nodes are processed. 991 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.998 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 992 999 ///By default it is a NullMap. 993 1000 typedef NullMap<typename Digraph::Node,bool> ProcessedMap; … … 1009 1016 1010 1017 ///The type of the map that stores the distances of the nodes. 1011 ///It must meetthe \ref concepts::WriteMap "WriteMap" concept.1018 ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. 1012 1019 typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap; 1013 1020 ///Instantiates a DistMap. … … 1024 1031 1025 1032 ///The type of the shortest paths. 1026 ///It must meetthe \ref concepts::Path "Path" concept.1033 ///It must conform to the \ref concepts::Path "Path" concept. 1027 1034 typedef lemon::Path<Digraph> Path; 1028 1035 }; … … 1030 1037 /// Default traits class used by DijkstraWizard 1031 1038 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. 1039 /// Default traits class used by DijkstraWizard. 1040 /// \tparam GR The type of the digraph. 1041 /// \tparam LEN The type of the length map. 1038 1042 template<typename GR, typename LEN> 1039 1043 class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN> … … 1094 1098 typedef TR Base; 1095 1099 1096 ///The type of the digraph the algorithm runs on.1097 1100 typedef typename TR::Digraph Digraph; 1098 1101 … … 1102 1105 typedef typename Digraph::OutArcIt OutArcIt; 1103 1106 1104 ///The type of the map that stores the arc lengths.1105 1107 typedef typename TR::LengthMap LengthMap; 1106 ///The type of the length of the arcs.1107 1108 typedef typename LengthMap::Value Value; 1108 ///\brief The type of the map that stores the predecessor1109 ///arcs of the shortest paths.1110 1109 typedef typename TR::PredMap PredMap; 1111 ///The type of the map that stores the distances of the nodes.1112 1110 typedef typename TR::DistMap DistMap; 1113 ///The type of the map that indicates which nodes are processed.1114 1111 typedef typename TR::ProcessedMap ProcessedMap; 1115 ///The type of the shortest paths1116 1112 typedef typename TR::Path Path; 1117 ///The heap type used by the dijkstra algorithm.1118 1113 typedef typename TR::Heap Heap; 1119 1114 … … 1187 1182 SetPredMapBase(const TR &b) : TR(b) {} 1188 1183 }; 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. 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. 1194 1190 template<class T> 1195 1191 DijkstraWizard<SetPredMapBase<T> > predMap(const T &t) … … 1205 1201 SetDistMapBase(const TR &b) : TR(b) {} 1206 1202 }; 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. 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. 1212 1210 template<class T> 1213 1211 DijkstraWizard<SetDistMapBase<T> > distMap(const T &t) … … 1223 1221 SetProcessedMapBase(const TR &b) : TR(b) {} 1224 1222 }; 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. 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. 1230 1229 template<class T> 1231 1230 DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t) … … 1240 1239 SetPathBase(const TR &b) : TR(b) {} 1241 1240 }; 1241 1242 1242 ///\brief \ref named-func-param "Named parameter" 1243 1243 ///for getting the shortest path to the target node. -
lemon/dim2.h
r463 r761 22 22 #include <iostream> 23 23 24 ///\ingroup misc24 ///\ingroup geomdat 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" implements29 /// a two dimensional vector with the usual operations.30 ///31 /// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine32 /// the rectangular bounding box of a set of33 /// \ref lemon::dim2::Point "dim2::Point"'s.34 27 35 28 namespace lemon { … … 41 34 namespace dim2 { 42 35 43 /// \addtogroup misc36 /// \addtogroup geomdat 44 37 /// @{ 45 38 -
lemon/edge_set.h
r717 r825 868 868 } 869 869 870 void next(Arc& arc) const{870 static void next(Arc& arc) { 871 871 --arc.id; 872 872 } … … 1174 1174 } 1175 1175 1176 void next(Arc& arc) const{1176 static void next(Arc& arc) { 1177 1177 --arc.id; 1178 1178 } … … 1182 1182 } 1183 1183 1184 void next(Edge& arc) const{1184 static void next(Edge& arc) { 1185 1185 --arc.id; 1186 1186 } -
lemon/fib_heap.h
r730 r758 21 21 22 22 ///\file 23 ///\ingroup auxdat24 ///\brief Fibonacci Heap implementation.23 ///\ingroup heaps 24 ///\brief Fibonacci heap implementation. 25 25 26 26 #include <vector> 27 #include <utility> 27 28 #include <functional> 28 29 #include <lemon/math.h> … … 30 31 namespace lemon { 31 32 32 /// \ingroup auxdat33 /// \ingroup heaps 33 34 /// 34 /// \brief Fibonacci Heap.35 /// \brief Fibonacci heap data structure. 35 36 /// 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. 37 /// This class implements the \e Fibonacci \e heap data structure. 38 /// It fully conforms to the \ref concepts::Heap "heap concept". 41 39 /// 42 /// The methods \ref increase and \ref erase are not efficient in a Fibonacci43 /// heap. In case of many calls to these operations, it is better to use a44 /// \ref BinHeap "binary heap".40 /// The methods \ref increase() and \ref erase() are not efficient in a 41 /// Fibonacci heap. In case of many calls of these operations, it is 42 /// better to use other heap structure, e.g. \ref BinHeap "binary heap". 45 43 /// 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 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>. 54 49 #ifdef DOXYGEN 55 template <typename PR IO, typename IM, typename CMP>50 template <typename PR, typename IM, typename CMP> 56 51 #else 57 template <typename PR IO, typename IM, typename CMP = std::less<PRIO> >52 template <typename PR, typename IM, typename CMP = std::less<PR> > 58 53 #endif 59 54 class FibHeap { 60 55 public: 61 ///\e 56 57 /// Type of the item-int map. 62 58 typedef IM ItemIntMap; 63 /// \e64 typedef PR IOPrio;65 /// \e59 /// Type of the priorities. 60 typedef PR Prio; 61 /// Type of the items stored in the heap. 66 62 typedef typename ItemIntMap::Key Item; 67 /// \e63 /// Type of the item-priority pairs. 68 64 typedef std::pair<Item,Prio> Pair; 69 /// \e65 /// Functor type for comparing the priorities. 70 66 typedef CMP Compare; 71 67 … … 81 77 public: 82 78 83 /// \brief Type to represent the items states.84 /// 85 /// Each Item element have a state associated to it. It maybe "in heap",86 /// "pre heap" or "postheap". The latter two are indifferent from the79 /// \brief Type to represent the states of the items. 80 /// 81 /// Each item has a state associated to it. It can be "in heap", 82 /// "pre-heap" or "post-heap". The latter two are indifferent from the 87 83 /// heap's point of view, but may be useful to the user. 88 84 /// … … 95 91 }; 96 92 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. 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. 101 99 explicit FibHeap(ItemIntMap &map) 102 100 : _minimum(0), _iim(map), _num() {} 103 101 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. 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. 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 /// Returns the number of items stored in the heap.114 /// This function returns the number of items stored in the heap. 115 115 int size() const { return _num; } 116 116 117 /// \brief Check s if the heap stores no items.118 /// 119 /// Returns \c true if and only if the heap stores no items.117 /// \brief Check if the heap is empty. 118 /// 119 /// This function returns \c true if the heap is empty. 120 120 bool empty() const { return _num==0; } 121 121 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. 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. 128 129 void clear() { 129 130 _data.clear(); _minimum = 0; _num = 0; 130 131 } 131 132 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) { 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) { 151 141 int i=_iim[item]; 152 142 if ( i < 0 ) { … … 169 159 _data[_minimum].right_neighbor=i; 170 160 _data[i].left_neighbor=_minimum; 171 if ( _comp( value, _data[_minimum].prio) ) _minimum=i;161 if ( _comp( prio, _data[_minimum].prio) ) _minimum=i; 172 162 } else { 173 163 _data[i].right_neighbor=_data[i].left_neighbor=i; 174 164 _minimum=i; 175 165 } 176 _data[i].prio= value;166 _data[i].prio=prio; 177 167 ++_num; 178 168 } 179 169 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. 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. 185 174 Item top() const { return _data[_minimum].name; } 186 175 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. 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. 205 185 /// \pre The heap must be non-empty. 206 186 void pop() { … … 209 189 _data[_minimum].in=false; 210 190 if ( _data[_minimum].degree!=0 ) { 211 make root(_data[_minimum].child);191 makeRoot(_data[_minimum].child); 212 192 _minimum=_data[_minimum].child; 213 193 balance(); … … 222 202 int last_child=_data[child].left_neighbor; 223 203 224 make root(child);204 makeRoot(child); 225 205 226 206 _data[left].right_neighbor=child; … … 235 215 } 236 216 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. 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. 241 223 void erase (const Item& item) { 242 224 int i=_iim[item]; … … 253 235 } 254 236 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) { 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) { 261 255 int i=_iim[item]; 262 _data[i].prio=value; 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; 263 271 int p=_data[i].parent; 264 272 265 if ( p!=-1 && _comp( value, _data[p].prio) ) {273 if ( p!=-1 && _comp(prio, _data[p].prio) ) { 266 274 cut(i,p); 267 275 cascade(p); 268 276 } 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) { 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) { 280 287 erase(item); 281 push(item, value);282 } 283 284 285 /// \brief Returns if \c item is in, has already been in, or has never286 /// been in the heap.287 /// 288 /// This method returns PRE_HEAP if \c item has never been in the289 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP290 /// otherwise. In the latter case it is possible that \c item will291 /// get back to the heap again.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 never 294 /// 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 back 297 /// to the heap again. 298 /// \param item The item. 292 299 State state(const Item &item) const { 293 300 int i=_iim[item]; … … 299 306 } 300 307 301 /// \brief Set s the state of the \citem in the heap.302 /// 303 /// Sets the state of the \c item in the heap. It can be used to304 /// manually clear the heap when it is important to achive the305 /// better time _complexity.308 /// \brief Set the state of an item 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 important 312 /// to achive better time complexity. 306 313 /// \param i The item. 307 314 /// \param st The state. It should not be \c IN_HEAP. … … 366 373 } 367 374 368 void make root(int c) {375 void makeRoot(int c) { 369 376 int s=c; 370 377 do { -
lemon/full_graph.h
r664 r827 25 25 ///\ingroup graphs 26 26 ///\file 27 ///\brief Full Graph and FullDigraph classes.27 ///\brief FullDigraph and FullGraph classes. 28 28 29 29 namespace lemon { … … 52 52 53 53 Node operator()(int ix) const { return Node(ix); } 54 int index(const Node& node) const{ return node._id; }54 static int index(const Node& node) { return node._id; } 55 55 56 56 Arc arc(const Node& s, const Node& t) const { … … 149 149 /// \ingroup graphs 150 150 /// 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, 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, 164 166 /// but there are two differences. While this class conforms only 165 /// to the \ref concepts::Digraph "Digraph" concept, the \cFullGraph166 /// c lass conforms to the \ref concepts::Graph "Graph" concept,167 /// moreover \c FullGraph does not contain a loop arcfor each168 /// node as \c FullDigraphdoes.167 /// to the \ref concepts::Digraph "Digraph" concept, FullGraph 168 /// conforms to the \ref concepts::Graph "Graph" concept, 169 /// moreover FullGraph does not contain a loop for each 170 /// node as this class does. 169 171 /// 170 172 /// \sa FullGraph … … 174 176 public: 175 177 176 /// \brief Constructor 178 /// \brief Default constructor. 179 /// 180 /// Default constructor. The number of nodes and arcs will be zero. 177 181 FullDigraph() { construct(0); } 178 182 … … 185 189 /// \brief Resizes the digraph 186 190 /// 187 /// Resizes the digraph. The function will fully destroyand188 /// rebuild the digraph. This cause that the maps of the digraph will191 /// This function resizes the digraph. It fully destroys and 192 /// rebuilds the structure, therefore the maps of the digraph will be 189 193 /// reallocated automatically and the previous values will be lost. 190 194 void resize(int n) { … … 198 202 /// \brief Returns the node with the given index. 199 203 /// 200 /// Returns the node with the given index. Since it is a static201 /// digraph its nodes can be indexed with integers from the range202 /// <tt>[0..nodeNum()-1]</tt>.204 /// Returns the node with the given index. Since this structure is 205 /// completely static, the nodes can be indexed with integers from 206 /// the range <tt>[0..nodeNum()-1]</tt>. 203 207 /// \sa index() 204 208 Node operator()(int ix) const { return Parent::operator()(ix); } … … 206 210 /// \brief Returns the index of the given node. 207 211 /// 208 /// Returns the index of the given node. Since it is a static209 /// digraph its nodes can be indexed with integers from the range210 /// <tt>[0..nodeNum()-1]</tt>.211 /// \sa operator() 212 int index(const Node& node) const{ return Parent::index(node); }212 /// Returns the index of the given node. Since this structure is 213 /// completely static, the nodes can be indexed with integers from 214 /// the range <tt>[0..nodeNum()-1]</tt>. 215 /// \sa operator()() 216 static int index(const Node& node) { return Parent::index(node); } 213 217 214 218 /// \brief Returns the arc connecting the given nodes. 215 219 /// 216 220 /// Returns the arc connecting the given nodes. 217 Arc arc( const Node& u, const Node&v) const {221 Arc arc(Node u, Node v) const { 218 222 return Parent::arc(u, v); 219 223 } … … 284 288 285 289 Node operator()(int ix) const { return Node(ix); } 286 int index(const Node& node) const{ return node._id; }290 static int index(const Node& node) { return node._id; } 287 291 288 292 Edge edge(const Node& u, const Node& v) const { … … 521 525 /// \brief An undirected full graph class. 522 526 /// 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 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 534 540 /// conforms only to the \ref concepts::Digraph "Digraph" concept, 535 541 /// this class conforms to the \ref concepts::Graph "Graph" concept, 536 /// moreover \c FullGraph does not contain a loop arcfor each537 /// node as \cFullDigraph does.542 /// moreover this class does not contain a loop for each 543 /// node as FullDigraph does. 538 544 /// 539 545 /// \sa FullDigraph … … 543 549 public: 544 550 545 /// \brief Constructor 551 /// \brief Default constructor. 552 /// 553 /// Default constructor. The number of nodes and edges will be zero. 546 554 FullGraph() { construct(0); } 547 555 … … 554 562 /// \brief Resizes the graph 555 563 /// 556 /// Resizes the graph. The function will fully destroyand557 /// rebuild the graph. This cause that the maps of the graph will564 /// This function resizes the graph. It fully destroys and 565 /// rebuilds the structure, therefore the maps of the graph will be 558 566 /// reallocated automatically and the previous values will be lost. 559 567 void resize(int n) { … … 569 577 /// \brief Returns the node with the given index. 570 578 /// 571 /// Returns the node with the given index. Since it is a static572 /// graph its nodes can be indexed with integers from the range573 /// <tt>[0..nodeNum()-1]</tt>.579 /// Returns the node with the given index. Since this structure is 580 /// completely static, the nodes can be indexed with integers from 581 /// the range <tt>[0..nodeNum()-1]</tt>. 574 582 /// \sa index() 575 583 Node operator()(int ix) const { return Parent::operator()(ix); } … … 577 585 /// \brief Returns the index of the given node. 578 586 /// 579 /// Returns the index of the given node. Since it is a static580 /// graph its nodes can be indexed with integers from the range581 /// <tt>[0..nodeNum()-1]</tt>.582 /// \sa operator() 583 int index(const Node& node) const{ return Parent::index(node); }587 /// Returns the index of the given node. Since this structure is 588 /// completely static, the nodes can be indexed with integers from 589 /// the range <tt>[0..nodeNum()-1]</tt>. 590 /// \sa operator()() 591 static int index(const Node& node) { return Parent::index(node); } 584 592 585 593 /// \brief Returns the arc connecting the given nodes. 586 594 /// 587 595 /// Returns the arc connecting the given nodes. 588 Arc arc( const Node& s, const Node&t) const {596 Arc arc(Node s, Node t) const { 589 597 return Parent::arc(s, t); 590 598 } 591 599 592 /// \brief Returns the edge connect sthe given nodes.593 /// 594 /// Returns the edge connect sthe given nodes.595 Edge edge( const Node& u, const Node&v) const {600 /// \brief Returns the edge connecting the given nodes. 601 /// 602 /// Returns the edge connecting the given nodes. 603 Edge edge(Node u, Node v) const { 596 604 return Parent::edge(u, v); 597 605 } -
lemon/glpk.cc
r623 r793 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()); 59 95 return i; 60 96 } -
lemon/glpk.h
r697 r793 55 55 virtual int _addCol(); 56 56 virtual int _addRow(); 57 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); 57 58 58 59 virtual void _eraseCol(int i); -
lemon/gomory_hu.h
r643 r760 360 360 /// \c t. 361 361 /// \code 362 /// Gomor uHu<Graph> gom(g, capacities);362 /// GomoryHu<Graph> gom(g, capacities); 363 363 /// gom.run(); 364 364 /// int cnt=0; 365 /// for(Gomor uHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;365 /// for(GomoryHu<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 uHu<Graph> gom(g, capacities);459 /// GomoryHu<Graph> gom(g, capacities); 460 460 /// gom.run(); 461 461 /// int value=0; 462 /// for(Gomor uHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)462 /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e) 463 463 /// value+=capacities[e]; 464 464 /// \endcode -
lemon/grid_graph.h
r664 r782 471 471 /// \brief Grid graph class 472 472 /// 473 /// This classimplements a special graph type. The nodes of the474 /// graph can be indexed by two integer \c (i,j) valuewhere \c i is475 /// in the \c [0..width()-1] range and j is in the \c476 /// [0..height()-1] range.Two nodes are connected in the graph if477 /// the ind exes differ exactly on one position and exactly one is478 /// the difference. The nodes of the graph can be indexed by position479 /// with the \c operator()() function. The positions of the nodes can be480 /// get with\c pos(), \c col() and \c row() members. The outgoing473 /// GridGraph implements a special graph type. The nodes of the 474 /// graph can be indexed by two integer values \c (i,j) where \c i is 475 /// in the range <tt>[0..width()-1]</tt> and j is in the range 476 /// <tt>[0..height()-1]</tt>. Two nodes are connected in the graph if 477 /// the indices differ exactly on one position and the difference is 478 /// also exactly one. The nodes of the graph can be obtained by position 479 /// using the \c operator()() function and the indices of the nodes can 480 /// be obtained using \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, however 487 /// the structure can be resized using resize(). 484 488 /// 485 489 /// \image html grid_graph.png … … 497 501 ///\endcode 498 502 /// 499 /// This graph type fully conforms to the \ref concepts::Graph 500 /// "Graph concept". 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. 501 506 class GridGraph : public ExtendedGridGraphBase { 502 507 typedef ExtendedGridGraphBase Parent; … … 504 509 public: 505 510 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>. 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>". 509 516 class IndexMap { 510 517 public: … … 515 522 516 523 /// \brief Constructor 517 ///518 /// Constructor519 524 IndexMap(const GridGraph& graph) : _graph(graph) {} 520 525 521 526 /// \brief The subscript operator 522 ///523 /// The subscript operator.524 527 Value operator[](Key key) const { 525 528 return _graph.pos(key); … … 541 544 542 545 /// \brief Constructor 543 ///544 /// Constructor545 546 ColMap(const GridGraph& graph) : _graph(graph) {} 546 547 547 548 /// \brief The subscript operator 548 ///549 /// The subscript operator.550 549 Value operator[](Key key) const { 551 550 return _graph.col(key); … … 567 566 568 567 /// \brief Constructor 569 ///570 /// Constructor571 568 RowMap(const GridGraph& graph) : _graph(graph) {} 572 569 573 570 /// \brief The subscript operator 574 ///575 /// The subscript operator.576 571 Value operator[](Key key) const { 577 572 return _graph.row(key); … … 584 579 /// \brief Constructor 585 580 /// 586 /// Construct a grid graph with given size.581 /// Construct a grid graph with the given size. 587 582 GridGraph(int width, int height) { construct(width, height); } 588 583 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. 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. 595 589 void resize(int width, int height) { 596 590 Parent::notifier(Arc()).clear(); … … 610 604 } 611 605 612 /// \brief Gives back the column index of the node.606 /// \brief The column index of the node. 613 607 /// 614 608 /// Gives back the column index of the node. … … 617 611 } 618 612 619 /// \brief Gives back the row index of the node.613 /// \brief The row index of the node. 620 614 /// 621 615 /// Gives back the row index of the node. … … 624 618 } 625 619 626 /// \brief Gives back the position of the node.620 /// \brief The position of the node. 627 621 /// 628 622 /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair. … … 631 625 } 632 626 633 /// \brief Gives back the number of the columns.627 /// \brief The number of the columns. 634 628 /// 635 629 /// Gives back the number of the columns. … … 638 632 } 639 633 640 /// \brief Gives back the number of the rows.634 /// \brief The number of the rows. 641 635 /// 642 636 /// Gives back the number of the rows. … … 645 639 } 646 640 647 /// \brief Gives back the arc goes right from the node.641 /// \brief The arc goes right from the node. 648 642 /// 649 643 /// Gives back the arc goes right from the node. If there is not … … 653 647 } 654 648 655 /// \brief Gives back the arc goes left from the node.649 /// \brief The arc goes left from the node. 656 650 /// 657 651 /// Gives back the arc goes left from the node. If there is not … … 661 655 } 662 656 663 /// \brief Gives back the arc goes up from the node.657 /// \brief The arc goes up from the node. 664 658 /// 665 659 /// Gives back the arc goes up from the node. If there is not … … 669 663 } 670 664 671 /// \brief Gives back the arc goes down from the node.665 /// \brief The arc goes down from the node. 672 666 /// 673 667 /// Gives back the arc goes down from the node. If there is not -
lemon/hypercube_graph.h
r664 r827 263 263 } 264 264 265 int index(Node node) const{265 static int index(Node node) { 266 266 return node._id; 267 267 } … … 283 283 /// \brief Hypercube graph class 284 284 /// 285 /// This class implements a special graph type. The nodes of the graph286 /// are indiced with integers withat most \c dim binary digits.285 /// HypercubeGraph implements a special graph type. The nodes of the 286 /// graph are indexed with integers having 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, however 291 /// 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 documented 295 /// only in the concept class. 289 296 /// 290 297 /// \note The type of the indices is chosen to \c int for efficiency 291 298 /// reasons. Thus the maximum dimension of this implementation is 26 292 299 /// (assuming that the size of \c int is 32 bit). 293 ///294 /// This graph type fully conforms to the \ref concepts::Graph295 /// "Graph concept".296 300 class HypercubeGraph : public ExtendedHypercubeGraphBase { 297 301 typedef ExtendedHypercubeGraphBase Parent; … … 303 307 /// Constructs a hypercube graph with \c dim dimensions. 304 308 HypercubeGraph(int dim) { construct(dim); } 309 310 /// \brief Resizes the graph 311 /// 312 /// This function resizes the graph. It fully destroys and 313 /// rebuilds the structure, therefore the maps of the graph will be 314 /// 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 } 305 324 306 325 /// \brief The number of dimensions. … … 321 340 /// 322 341 /// Gives back the dimension id of the given edge. 323 /// It is in the [0..dim-1] range.342 /// It is in the range <tt>[0..dim-1]</tt>. 324 343 int dimension(Edge edge) const { 325 344 return Parent::dimension(edge); … … 329 348 /// 330 349 /// Gives back the dimension id of the given arc. 331 /// It is in the [0..dim-1] range.350 /// It is in the range <tt>[0..dim-1]</tt>. 332 351 int dimension(Arc arc) const { 333 352 return Parent::dimension(arc); … … 338 357 /// Gives back the index of the given node. 339 358 /// The lower bits of the integer describes the node. 340 int index(Node node) const{359 static int index(Node node) { 341 360 return Parent::index(node); 342 361 } -
lemon/list_graph.h
r664 r788 22 22 ///\ingroup graphs 23 23 ///\file 24 ///\brief ListDigraph ,ListGraph classes.24 ///\brief ListDigraph and ListGraph classes. 25 25 26 26 #include <lemon/core.h> … … 32 32 33 33 namespace lemon { 34 35 class ListDigraph; 34 36 35 37 class ListDigraphBase { … … 63 65 class Node { 64 66 friend class ListDigraphBase; 67 friend class ListDigraph; 65 68 protected: 66 69 … … 78 81 class Arc { 79 82 friend class ListDigraphBase; 83 friend class ListDigraph; 80 84 protected: 81 85 … … 117 121 int n; 118 122 for(n = first_node; 119 n !=-1 && nodes[n].first_in== -1;123 n != -1 && nodes[n].first_out == -1; 120 124 n = nodes[n].next) {} 121 arc.id = (n == -1) ? -1 : nodes[n].first_ in;125 arc.id = (n == -1) ? -1 : nodes[n].first_out; 122 126 } 123 127 124 128 void next(Arc& arc) const { 125 if (arcs[arc.id].next_ in!= -1) {126 arc.id = arcs[arc.id].next_ in;129 if (arcs[arc.id].next_out != -1) { 130 arc.id = arcs[arc.id].next_out; 127 131 } else { 128 132 int n; 129 for(n = nodes[arcs[arc.id]. target].next;130 n !=-1 && nodes[n].first_in== -1;133 for(n = nodes[arcs[arc.id].source].next; 134 n != -1 && nodes[n].first_out == -1; 131 135 n = nodes[n].next) {} 132 arc.id = (n == -1) ? -1 : nodes[n].first_ in;136 arc.id = (n == -1) ? -1 : nodes[n].first_out; 133 137 } 134 138 } … … 312 316 ///A general directed graph structure. 313 317 314 ///\ref ListDigraph is a simple and fast <em>directed graph</em>315 ///implementation based on staticlinked lists that are stored in318 ///\ref ListDigraph is a versatile and fast directed graph 319 ///implementation based on linked lists that are stored in 316 320 ///\c std::vector structures. 317 321 /// 318 /// It conforms to the \ref concepts::Digraph "Digraph concept" and it319 ///a lso provides several useful additional functionalities.320 ///Most of themember functions and nested classes are documented322 ///This type fully conforms to the \ref concepts::Digraph "Digraph concept" 323 ///and it also provides several useful additional functionalities. 324 ///Most of its member functions and nested classes are documented 321 325 ///only in the concept class. 322 326 /// 323 327 ///\sa concepts::Digraph 324 328 ///\sa ListGraph 325 329 class ListDigraph : public ExtendedListDigraphBase { 326 330 typedef ExtendedListDigraphBase Parent; 327 331 328 332 private: 329 ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. 330 331 ///ListDigraph is \e not copy constructible. Use copyDigraph() instead. 332 /// 333 /// Digraphs are \e not copy constructible. Use DigraphCopy instead. 333 334 ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {}; 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. 335 /// \brief Assignment of a digraph to another one is \e not allowed. 336 /// Use DigraphCopy instead. 339 337 void operator=(const ListDigraph &) {} 340 338 public: … … 348 346 ///Add a new node to the digraph. 349 347 350 /// Adda new node to the digraph.348 ///This function adds a new node to the digraph. 351 349 ///\return The new node. 352 350 Node addNode() { return Parent::addNode(); } … … 354 352 ///Add a new arc to the digraph. 355 353 356 /// Adda new arc to the digraph with source node \c s354 ///This function adds a new arc to the digraph with source node \c s 357 355 ///and target node \c t. 358 356 ///\return The new arc. 359 Arc addArc( const Node& s, const Node&t) {357 Arc addArc(Node s, Node t) { 360 358 return Parent::addArc(s, t); 361 359 } … … 363 361 ///\brief Erase a node from the digraph. 364 362 /// 365 ///Erase a node from the digraph. 366 /// 367 void erase(const Node& n) { Parent::erase(n); } 363 ///This function erases the given node from the digraph. 364 void erase(Node n) { Parent::erase(n); } 368 365 369 366 ///\brief Erase an arc from the digraph. 370 367 /// 371 ///Erase an arc from the digraph. 372 /// 373 void erase(const Arc& a) { Parent::erase(a); } 368 ///This function erases the given arc from the digraph. 369 void erase(Arc a) { Parent::erase(a); } 374 370 375 371 /// Node validity check 376 372 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. 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. 383 378 bool valid(Node n) const { return Parent::valid(n); } 384 379 385 380 /// Arc validity check 386 381 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. 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. 393 387 bool valid(Arc a) const { return Parent::valid(a); } 394 388 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. 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. 402 395 /// 403 396 ///\warning This functionality cannot be used together with the Snapshot … … 406 399 Parent::changeTarget(a,n); 407 400 } 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. 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. 415 407 /// 416 408 ///\warning This functionality cannot be used together with the Snapshot … … 420 412 } 421 413 422 /// Invertthe direction of an arc.423 424 /// \note The <tt>ArcIt</tt>s referencing the changed arc remain425 /// valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are426 /// invalidated.414 /// Reverse the 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 referencing 418 ///the changed arc are invalidated. 427 419 /// 428 420 ///\warning This functionality cannot be used together with the Snapshot 429 421 ///feature. 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); }; 422 void reverseArc(Arc a) { 423 Node t=target(a); 424 changeTarget(a,source(a)); 425 changeSource(a,t); 426 } 455 427 456 428 ///Contract two nodes. 457 429 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. 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. 467 442 /// 468 443 ///\warning This functionality cannot be used together with the Snapshot 469 444 ///feature. 470 void contract(Node a, Node b, bool r = true)445 void contract(Node u, Node v, bool r = true) 471 446 { 472 for(OutArcIt e(*this, b);e!=INVALID;) {447 for(OutArcIt e(*this,v);e!=INVALID;) { 473 448 OutArcIt f=e; 474 449 ++f; 475 if(r && target(e)== a) erase(e);476 else changeSource(e, a);450 if(r && target(e)==u) erase(e); 451 else changeSource(e,u); 477 452 e=f; 478 453 } 479 for(InArcIt e(*this, b);e!=INVALID;) {454 for(InArcIt e(*this,v);e!=INVALID;) { 480 455 InArcIt f=e; 481 456 ++f; 482 if(r && source(e)== a) erase(e);483 else changeTarget(e, a);457 if(r && source(e)==u) erase(e); 458 else changeTarget(e,u); 484 459 e=f; 485 460 } 486 erase( b);461 erase(v); 487 462 } 488 463 489 464 ///Split a node. 490 465 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. 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. 495 472 ///\return The newly created node. 496 473 /// 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 474 ///\note All iterators remain valid. 475 /// 476 ///\warning This functionality cannot be used together with the 502 477 ///Snapshot feature. 503 478 Node split(Node n, bool connect = true) { 504 479 Node b = addNode(); 505 for(OutArcIt e(*this,n);e!=INVALID;) { 506 OutArcIt f=e; 507 ++f; 508 changeSource(e,b); 509 e=f; 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; 510 484 } 511 485 if (connect) addArc(n,b); … … 515 489 ///Split an arc. 516 490 517 ///This function splits an arc. First a new node \c b is added to518 /// the digraph, then the original arc is re-targeted to \c519 /// b. Finally an arc from \c b to the original target is added.520 /// 491 ///This function splits the given arc. First, a new node \c v is 492 ///added to the digraph, then the target node of the original arc 493 ///is set to \c v. Finally, an arc from \c v to the original target 494 ///is added. 521 495 ///\return The newly created node. 496 /// 497 ///\note \c InArcIt iterators referencing the original arc are 498 ///invalidated. Other iterators remain valid. 522 499 /// 523 500 ///\warning This functionality cannot be used together with the 524 501 ///Snapshot feature. 525 Node split(Arc e) { 526 Node b = addNode(); 527 addArc(b,target(e)); 528 changeTarget(e,b); 529 return b; 530 } 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); }; 531 536 532 537 /// \brief Class to make a snapshot of the digraph and restore … … 538 543 /// restore() function. 539 544 /// 540 /// \warning Arc and node deletions and other modifications (e.g. 541 /// contracting, splitting, reversing arcs or nodes) cannot be 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 542 551 /// restored. These events invalidate the snapshot. 552 /// However the arcs and nodes that were added to the digraph after 553 /// making the current snapshot can be removed without invalidating it. 543 554 class Snapshot { 544 555 protected: … … 710 721 /// 711 722 /// Default constructor. 712 /// To actually make a snapshot you must call save().723 /// You have to call save() to actually make a snapshot. 713 724 Snapshot() 714 725 : digraph(0), node_observer_proxy(*this), … … 717 728 /// \brief Constructor that immediately makes a snapshot. 718 729 /// 719 /// This constructor immediately makes a snapshot of the digraph. 720 /// \param _digraph The digraph we make a snapshot of. 721 Snapshot(ListDigraph &_digraph) 730 /// This constructor immediately makes a snapshot of the given digraph. 731 Snapshot(ListDigraph &gr) 722 732 : node_observer_proxy(*this), 723 733 arc_observer_proxy(*this) { 724 attach( _digraph);734 attach(gr); 725 735 } 726 736 727 737 /// \brief Make a snapshot. 728 738 /// 729 /// Make a snapshot of the digraph. 730 /// 731 /// This function can be called more than once. In case of a repeated 739 /// This function makes a snapshot of the given digraph. 740 /// It can be called more than once. In case of a repeated 732 741 /// call, the previous snapshot gets lost. 733 /// \param _digraph The digraph we make the snapshot of. 734 void save(ListDigraph &_digraph) { 742 void save(ListDigraph &gr) { 735 743 if (attached()) { 736 744 detach(); 737 745 clear(); 738 746 } 739 attach( _digraph);747 attach(gr); 740 748 } 741 749 742 750 /// \brief Undo the changes until the last snapshot. 743 // 744 /// Undo the changes until the last snapshot created by save(). 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. 745 757 void restore() { 746 758 detach(); … … 756 768 } 757 769 758 /// \brief Gives back true whenthe snapshot is valid.770 /// \brief Returns \c true if the snapshot is valid. 759 771 /// 760 /// Gives back true whenthe snapshot is valid.772 /// This function returns \c true if the snapshot is valid. 761 773 bool valid() const { 762 774 return attached(); … … 795 807 796 808 typedef ListGraphBase Graph; 797 798 class Node;799 class Arc;800 class Edge;801 809 802 810 class Node { … … 848 856 bool operator<(const Arc& arc) const {return id < arc.id;} 849 857 }; 850 851 852 858 853 859 ListGraphBase() … … 1165 1171 ///A general undirected graph structure. 1166 1172 1167 ///\ref ListGraph is a simple and fast <em>undirected graph</em>1168 ///implementation based on staticlinked lists that are stored in1173 ///\ref ListGraph is a versatile and fast undirected graph 1174 ///implementation based on linked lists that are stored in 1169 1175 ///\c std::vector structures. 1170 1176 /// 1171 /// It conforms to the \ref concepts::Graph "Graph concept" and it1172 ///a lso provides several useful additional functionalities.1173 ///Most of themember functions and nested classes are documented1177 ///This type fully conforms to the \ref concepts::Graph "Graph concept" 1178 ///and it also provides several useful additional functionalities. 1179 ///Most of its member functions and nested classes are documented 1174 1180 ///only in the concept class. 1175 1181 /// 1176 1182 ///\sa concepts::Graph 1177 1183 ///\sa ListDigraph 1178 1184 class ListGraph : public ExtendedListGraphBase { 1179 1185 typedef ExtendedListGraphBase Parent; 1180 1186 1181 1187 private: 1182 ///ListGraph is \e not copy constructible. Use copyGraph() instead. 1183 1184 ///ListGraph is \e not copy constructible. Use copyGraph() instead. 1185 /// 1188 /// Graphs are \e not copy constructible. Use GraphCopy instead. 1186 1189 ListGraph(const ListGraph &) :ExtendedListGraphBase() {}; 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. 1190 /// \brief Assignment of a graph to another one is \e not allowed. 1191 /// Use GraphCopy instead. 1192 1192 void operator=(const ListGraph &) {} 1193 1193 public: … … 1202 1202 /// \brief Add a new node to the graph. 1203 1203 /// 1204 /// Adda new node to the graph.1204 /// This function adds 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 /// Add a new edge to the graph with source node \c s 1211 /// and target node \c t. 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. 1212 1213 /// \return The new edge. 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); } 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); } 1228 1227 /// Node validity check 1229 1228 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 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 1235 1233 /// added to the graph. 1236 1234 bool valid(Node n) const { return Parent::valid(n); } 1235 /// Edge validity check 1236 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 1241 /// added to the graph. 1242 bool valid(Edge e) const { return Parent::valid(e); } 1237 1243 /// Arc validity check 1238 1244 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 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 1244 1249 /// added to the graph. 1245 1250 bool valid(Arc a) const { return Parent::valid(a); } 1246 /// Edge validity check 1247 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 1253 /// added to the graph. 1254 bool valid(Edge e) const { return Parent::valid(e); } 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. 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. 1263 1259 /// 1264 1260 ///\warning This functionality cannot be used together with the … … 1267 1263 Parent::changeU(e,n); 1268 1264 } 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. 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. 1276 1273 /// 1277 1274 ///\warning This functionality cannot be used together with the … … 1280 1277 Parent::changeV(e,n); 1281 1278 } 1279 1282 1280 /// \brief Contract two nodes. 1283 1281 /// 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. 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. 1292 1293 /// 1293 1294 ///\warning This functionality cannot be used together with the … … 1308 1309 } 1309 1310 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 memory 1322 /// allocation: if you know that the graph you want to build will 1323 /// be large (e.g. it will contain millions of nodes and/or edges), 1324 /// then it is worth reserving space for this amount before starting 1325 /// 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 memory 1332 /// allocation: if you know that the graph you want to build will 1333 /// be large (e.g. it will contain millions of nodes and/or edges), 1334 /// then it is worth reserving space for this amount before starting 1335 /// to build the graph. 1336 /// \sa reserveNode() 1337 void reserveEdge(int m) { arcs.reserve(2 * m); }; 1310 1338 1311 1339 /// \brief Class to make a snapshot of the graph and restore … … 1317 1345 /// using the restore() function. 1318 1346 /// 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. 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. 1322 1356 class Snapshot { 1323 1357 protected: … … 1489 1523 /// 1490 1524 /// Default constructor. 1491 /// To actually make a snapshot you must call save().1525 /// You have to call save() to actually make a snapshot. 1492 1526 Snapshot() 1493 1527 : graph(0), node_observer_proxy(*this), … … 1496 1530 /// \brief Constructor that immediately makes a snapshot. 1497 1531 /// 1498 /// This constructor immediately makes a snapshot of the graph. 1499 /// \param _graph The graph we make a snapshot of. 1500 Snapshot(ListGraph &_graph) 1532 /// This constructor immediately makes a snapshot of the given graph. 1533 Snapshot(ListGraph &gr) 1501 1534 : node_observer_proxy(*this), 1502 1535 edge_observer_proxy(*this) { 1503 attach( _graph);1536 attach(gr); 1504 1537 } 1505 1538 1506 1539 /// \brief Make a snapshot. 1507 1540 /// 1508 /// Make a snapshot of the graph. 1509 /// 1510 /// This function can be called more than once. In case of a repeated 1541 /// This function makes a snapshot of the given graph. 1542 /// It can be called more than once. In case of a repeated 1511 1543 /// call, the previous snapshot gets lost. 1512 /// \param _graph The graph we make the snapshot of. 1513 void save(ListGraph &_graph) { 1544 void save(ListGraph &gr) { 1514 1545 if (attached()) { 1515 1546 detach(); 1516 1547 clear(); 1517 1548 } 1518 attach( _graph);1549 attach(gr); 1519 1550 } 1520 1551 1521 1552 /// \brief Undo the changes until the last snapshot. 1522 // 1523 /// Undo the changes until the last snapshot created by save(). 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. 1524 1559 void restore() { 1525 1560 detach(); … … 1535 1570 } 1536 1571 1537 /// \brief Gives back true whenthe snapshot is valid.1572 /// \brief Returns \c true if the snapshot is valid. 1538 1573 /// 1539 /// Gives back true whenthe snapshot is valid.1574 /// This function returns \c true if the snapshot is valid. 1540 1575 bool valid() const { 1541 1576 return attached(); -
lemon/lp_base.h
r631 r793 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 946 954 virtual void _eraseCol(int col) = 0; 947 955 virtual void _eraseRow(int row) = 0; … … 1208 1216 ///\return The created row. 1209 1217 Row addRow(Value l,const Expr &e, Value u) { 1210 Row r=addRow(); 1211 row(r,l,e,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)); 1212 1222 return r; 1213 1223 } … … 1218 1228 ///\return The created row. 1219 1229 Row addRow(const Constr &c) { 1220 Row r=addRow(); 1221 row(r,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)); 1222 1236 return r; 1223 1237 } -
lemon/lp_skeleton.cc
r623 r793 29 29 30 30 int SkeletonSolverBase::_addRow() 31 { 32 return ++row_num; 33 } 34 35 int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value) 31 36 { 32 37 return ++row_num; -
lemon/lp_skeleton.h
r623 r793 45 45 /// \e 46 46 virtual int _addRow(); 47 /// \e 48 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); 47 49 /// \e 48 50 virtual void _eraseCol(int i); -
lemon/maps.h
r664 r836 23 23 #include <functional> 24 24 #include <vector> 25 #include <map> 25 26 26 27 #include <lemon/core.h> … … 29 30 ///\ingroup maps 30 31 ///\brief Miscellaneous property maps 31 32 #include <map>33 32 34 33 namespace lemon { … … 58 57 /// but data written to it is not required (i.e. it will be sent to 59 58 /// <tt>/dev/null</tt>). 60 /// It conforms t he \ref concepts::ReadWriteMap "ReadWriteMap" concept.59 /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept. 61 60 /// 62 61 /// \sa ConstMap … … 91 90 /// 92 91 /// In other aspects it is equivalent to \c NullMap. 93 /// So it conforms t he \ref concepts::ReadWriteMap "ReadWriteMap"92 /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" 94 93 /// concept, but it absorbs the data written to it. 95 94 /// … … 160 159 /// 161 160 /// In other aspects it is equivalent to \c NullMap. 162 /// So it conforms t he \ref concepts::ReadWriteMap "ReadWriteMap"161 /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" 163 162 /// concept, but it absorbs the data written to it. 164 163 /// … … 234 233 /// It can be used with some data structures, for example 235 234 /// \c UnionFind, \c BinHeap, when the used items are small 236 /// integers. This map conforms t he \ref concepts::ReferenceMap235 /// integers. This map conforms to the \ref concepts::ReferenceMap 237 236 /// "ReferenceMap" concept. 238 237 /// … … 342 341 /// stored actually. This value can be different from the default 343 342 /// contructed value (i.e. \c %Value()). 344 /// This type conforms t he \ref concepts::ReferenceMap "ReferenceMap"343 /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap" 345 344 /// concept. 346 345 /// … … 708 707 /// The \c Key type of it is inherited from \c M and the \c Value 709 708 /// type is \c V. 710 /// This type conforms t he \ref concepts::ReadMap "ReadMap" concept.709 /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept. 711 710 /// 712 711 /// The simplest way of using this map is through the convertMap() … … 1791 1790 /// \code 1792 1791 /// std::vector<Node> v; 1793 /// dfs(g ,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();1792 /// dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s); 1794 1793 /// \endcode 1795 1794 /// \code 1796 1795 /// std::vector<Node> v(countNodes(g)); 1797 /// dfs(g ,s).processedMap(loggerBoolMap(v.begin())).run();1796 /// dfs(g).processedMap(loggerBoolMap(v.begin())).run(s); 1798 1797 /// \endcode 1799 1798 /// … … 1819 1818 /// 1820 1819 /// IdMap provides a unique and immutable id for each item of the 1821 /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 1820 /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 1822 1821 /// - \b unique: different items get different ids, 1823 1822 /// - \b immutable: the id of an item does not change (even if you … … 1827 1826 /// the items stored in the graph, which is returned by the \c id() 1828 1827 /// function of the graph. This map can be inverted with its member 1829 /// class \c InverseMap or with the \c operator() member.1828 /// class \c InverseMap or with the \c operator()() member. 1830 1829 /// 1831 1830 /// \tparam GR The graph type. … … 1867 1866 public: 1868 1867 1869 /// \brief This class represents the inverse of its owner (IdMap). 1870 /// 1871 /// This class represents the inverse of its owner (IdMap). 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. 1872 1873 /// \see inverse() 1873 1874 class InverseMap { … … 1884 1885 explicit InverseMap(const IdMap& map) : _graph(map._graph) {} 1885 1886 1886 /// \brief Gives back the given item fromits id.1887 /// \brief Gives back an item by its id. 1887 1888 /// 1888 /// Gives back the given item fromits id.1889 /// Gives back an item by its id. 1889 1890 Item operator[](int id) const { return _graph->fromId(id, Item());} 1890 1891 … … 1899 1900 }; 1900 1901 1902 /// \brief Returns an \c IdMap class. 1903 /// 1904 /// This function just returns an \c IdMap class. 1905 /// \relates IdMap 1906 template <typename K, typename GR> 1907 inline IdMap<GR, K> idMap(const GR& graph) { 1908 return IdMap<GR, K>(graph); 1909 } 1901 1910 1902 1911 /// \brief General cross reference graph map type. 1903 1912 1904 1913 /// This class provides simple invertable graph maps. 1905 /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap" 1906 /// and if a key is set to a new value then store it 1907 /// in the inverse map. 1908 /// 1909 /// The values of the map can be accessed 1910 /// with stl compatible forward iterator. 1914 /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap) 1915 /// 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. 1927 /// 1928 /// This type is not reference map, so it cannot be modified with 1929 /// the subscript operator. 1911 1930 /// 1912 1931 /// \tparam GR The graph type. … … 1924 1943 template Map<V>::Type Map; 1925 1944 1926 typedef std::m ap<V, K> Container;1945 typedef std::multimap<V, K> Container; 1927 1946 Container _inv_map; 1928 1947 … … 1946 1965 /// \brief Forward iterator for values. 1947 1966 /// 1948 /// This iterator is an stlcompatible forward1967 /// This iterator is an STL compatible forward 1949 1968 /// iterator on the values of the map. The values can 1950 1969 /// be accessed in the <tt>[beginValue, endValue)</tt> range. 1951 class ValueIterator 1970 /// They are considered with multiplicity, so each value is 1971 /// traversed for each item it is assigned to. 1972 class ValueIt 1952 1973 : public std::iterator<std::forward_iterator_tag, Value> { 1953 1974 friend class CrossRefMap; 1954 1975 private: 1955 ValueIt erator(typename Container::const_iterator _it)1976 ValueIt(typename Container::const_iterator _it) 1956 1977 : it(_it) {} 1957 1978 public: 1958 1979 1959 ValueIterator() {} 1960 1961 ValueIterator& operator++() { ++it; return *this; } 1962 ValueIterator operator++(int) { 1963 ValueIterator tmp(*this); 1980 /// Constructor 1981 ValueIt() {} 1982 1983 /// \e 1984 ValueIt& operator++() { ++it; return *this; } 1985 /// \e 1986 ValueIt operator++(int) { 1987 ValueIt tmp(*this); 1964 1988 operator++(); 1965 1989 return tmp; 1966 1990 } 1967 1991 1992 /// \e 1968 1993 const Value& operator*() const { return it->first; } 1994 /// \e 1969 1995 const Value* operator->() const { return &(it->first); } 1970 1996 1971 bool operator==(ValueIterator jt) const { return it == jt.it; } 1972 bool operator!=(ValueIterator jt) const { return it != jt.it; } 1997 /// \e 1998 bool operator==(ValueIt jt) const { return it == jt.it; } 1999 /// \e 2000 bool operator!=(ValueIt jt) const { return it != jt.it; } 1973 2001 1974 2002 private: 1975 2003 typename Container::const_iterator it; 1976 2004 }; 2005 2006 /// Alias for \c ValueIt 2007 typedef ValueIt ValueIterator; 1977 2008 1978 2009 /// \brief Returns an iterator to the first value. 1979 2010 /// 1980 /// Returns an stlcompatible iterator to the2011 /// Returns an STL compatible iterator to the 1981 2012 /// first value of the map. The values of the 1982 2013 /// map can be accessed in the <tt>[beginValue, endValue)</tt> 1983 2014 /// range. 1984 ValueIt eratorbeginValue() const {1985 return ValueIt erator(_inv_map.begin());2015 ValueIt beginValue() const { 2016 return ValueIt(_inv_map.begin()); 1986 2017 } 1987 2018 1988 2019 /// \brief Returns an iterator after the last value. 1989 2020 /// 1990 /// Returns an stlcompatible iterator after the2021 /// Returns an STL compatible iterator after the 1991 2022 /// last value of the map. The values of the 1992 2023 /// map can be accessed in the <tt>[beginValue, endValue)</tt> 1993 2024 /// range. 1994 ValueIt eratorendValue() const {1995 return ValueIt erator(_inv_map.end());2025 ValueIt endValue() const { 2026 return ValueIt(_inv_map.end()); 1996 2027 } 1997 2028 … … 2001 2032 void set(const Key& key, const Value& val) { 2002 2033 Value oldval = Map::operator[](key); 2003 typename Container::iterator it = _inv_map.find(oldval); 2004 if (it != _inv_map.end() && it->second == key) { 2005 _inv_map.erase(it); 2006 } 2007 _inv_map.insert(make_pair(val, key)); 2034 typename Container::iterator it; 2035 for (it = _inv_map.equal_range(oldval).first; 2036 it != _inv_map.equal_range(oldval).second; ++it) { 2037 if (it->second == key) { 2038 _inv_map.erase(it); 2039 break; 2040 } 2041 } 2042 _inv_map.insert(std::make_pair(val, key)); 2008 2043 Map::set(key, val); 2009 2044 } … … 2017 2052 } 2018 2053 2019 /// \brief Gives back the item by its value. 2020 /// 2021 /// Gives back the item by its value. 2022 Key operator()(const Value& key) const { 2023 typename Container::const_iterator it = _inv_map.find(key); 2054 /// \brief Gives back an item by its value. 2055 /// 2056 /// This function gives back an item that is assigned to 2057 /// the given value or \c INVALID if no such item exists. 2058 /// If there are more items with the same associated value, 2059 /// only one of them is returned. 2060 Key operator()(const Value& val) const { 2061 typename Container::const_iterator it = _inv_map.find(val); 2024 2062 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 value 2068 /// associated with it. 2069 int count(const Value &val) const { 2070 return _inv_map.count(val); 2025 2071 } 2026 2072 … … 2033 2079 virtual void erase(const Key& key) { 2034 2080 Value val = Map::operator[](key); 2035 typename Container::iterator it = _inv_map.find(val); 2036 if (it != _inv_map.end() && it->second == key) { 2037 _inv_map.erase(it); 2081 typename Container::iterator it; 2082 for (it = _inv_map.equal_range(val).first; 2083 it != _inv_map.equal_range(val).second; ++it) { 2084 if (it->second == key) { 2085 _inv_map.erase(it); 2086 break; 2087 } 2038 2088 } 2039 2089 Map::erase(key); … … 2047 2097 for (int i = 0; i < int(keys.size()); ++i) { 2048 2098 Value val = Map::operator[](keys[i]); 2049 typename Container::iterator it = _inv_map.find(val); 2050 if (it != _inv_map.end() && it->second == keys[i]) { 2051 _inv_map.erase(it); 2099 typename Container::iterator it; 2100 for (it = _inv_map.equal_range(val).first; 2101 it != _inv_map.equal_range(val).second; ++it) { 2102 if (it->second == keys[i]) { 2103 _inv_map.erase(it); 2104 break; 2105 } 2052 2106 } 2053 2107 } … … 2066 2120 public: 2067 2121 2068 /// \brief The inverse map type. 2069 /// 2070 /// The inverse of this map. The subscript operator of the map 2071 /// gives back the item that was last assigned to the value. 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() 2072 2128 class InverseMap { 2073 2129 public: … … 2085 2141 /// \brief Subscript operator. 2086 2142 /// 2087 /// Subscript operator. It gives back the item 2088 /// that was last assigned to the given value. 2143 /// Subscript operator. It gives back an item 2144 /// that is assigned to the given value or \c INVALID 2145 /// if no such item exists. 2089 2146 Value operator[](const Key& key) const { 2090 2147 return _inverted(key); … … 2095 2152 }; 2096 2153 2097 /// \brief It gives back the read-only inverse map.2098 /// 2099 /// It gives back the read-only inverse map.2154 /// \brief Gives back the inverse of the map. 2155 /// 2156 /// Gives back the inverse of the CrossRefMap. 2100 2157 InverseMap inverse() const { 2101 2158 return InverseMap(*this); … … 2104 2161 }; 2105 2162 2106 /// \brief Provides continuous and unique IDfor the2163 /// \brief Provides continuous and unique id for the 2107 2164 /// items of a graph. 2108 2165 /// 2109 2166 /// RangeIdMap provides a unique and continuous 2110 /// IDfor each item of a given type (\c Node, \c Arc or2167 /// id for each item of a given type (\c Node, \c Arc or 2111 2168 /// \c Edge) in a graph. This id is 2112 2169 /// - \b unique: different items get different ids, … … 2119 2176 /// the \c id() function of the graph or \ref IdMap. 2120 2177 /// This map can be inverted with its member class \c InverseMap, 2121 /// or with the \c operator() member.2178 /// or with the \c operator()() member. 2122 2179 /// 2123 2180 /// \tparam GR The graph type. … … 2247 2304 } 2248 2305 2249 /// \brief Gives back the \e RangeId of the item2250 /// 2251 /// Gives back the \e RangeId of the item.2306 /// \brief Gives back the \e range \e id of the item 2307 /// 2308 /// Gives back the \e range \e id of the item. 2252 2309 int operator[](const Item& item) const { 2253 2310 return Map::operator[](item); 2254 2311 } 2255 2312 2256 /// \brief Gives back the item belonging to a \e RangeId2257 /// 2258 /// Gives back the item belonging to a \e RangeId.2313 /// \brief Gives back the item belonging to a \e range \e id 2314 /// 2315 /// Gives back the item belonging to the given \e range \e id. 2259 2316 Item operator()(int id) const { 2260 2317 return _inv_map[id]; … … 2270 2327 /// \brief The inverse map type of RangeIdMap. 2271 2328 /// 2272 /// The inverse map type of RangeIdMap. 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. 2273 2332 class InverseMap { 2274 2333 public: … … 2288 2347 /// 2289 2348 /// Subscript operator. It gives back the item 2290 /// that the descriptorcurrently belongs to.2349 /// that the given \e range \e id currently belongs to. 2291 2350 Value operator[](const Key& key) const { 2292 2351 return _inverted(key); … … 2306 2365 /// \brief Gives back the inverse of the map. 2307 2366 /// 2308 /// Gives back the inverse of the map.2367 /// Gives back the inverse of the RangeIdMap. 2309 2368 const InverseMap inverse() const { 2310 2369 return InverseMap(*this); 2311 2370 } 2371 }; 2372 2373 /// \brief Returns a \c RangeIdMap class. 2374 /// 2375 /// This function just returns an \c RangeIdMap class. 2376 /// \relates RangeIdMap 2377 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 a 2385 /// \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 on 2387 /// the keys mapped to the value. 2388 /// 2389 /// This type is a reference map, so it can be modified with the 2390 /// subscript operator. 2391 /// 2392 /// \tparam GR The graph type. 2393 /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or 2394 /// \c GR::Edge). 2395 /// 2396 /// \see IterableIntMap, IterableValueMap 2397 /// \see CrossRefMap 2398 template <typename GR, typename K> 2399 class IterableBoolMap 2400 : 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 type 2416 typedef K Key; 2417 /// The value type 2418 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 to 2433 /// \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 works 2548 /// like a graph item iterator, it can be converted to 2549 /// the key type of the map, incremented with \c ++ operator, and 2550 /// if the iterator leaves the last valid key, it will be equal to 2551 /// \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 the 2559 /// 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 works 2587 /// like a graph item iterator, it can be converted to 2588 /// the key type of the map, incremented with \c ++ operator, and 2589 /// if the iterator leaves the last valid key, it will be equal to 2590 /// \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 the 2598 /// 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 works 2626 /// like a graph item iterator, it can be converted to 2627 /// the key type of the map, incremented with \c ++ operator, and 2628 /// if the iterator leaves the last valid key, it will be equal to 2629 /// \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 the 2637 /// 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 an 2752 /// 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 keys 2754 /// mapped to the value. 2755 /// 2756 /// This map is intended to be used with small integer values, for which 2757 /// 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 the 2762 /// subscript operator. 2763 /// 2764 /// \note The size of the data structure depends on the largest 2765 /// 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 or 2769 /// \c GR::Edge). 2770 /// 2771 /// \see IterableBoolMap, IterableValueMap 2772 /// \see CrossRefMap 2773 template <typename GR, typename K> 2774 class IterableIntMap 2775 : 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 type 2782 typedef K Key; 2783 /// The value type 2784 typedef int Value; 2785 /// The graph type 2786 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 can 2846 /// 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 works 2967 /// like a graph item iterator, it can be converted to 2968 /// the item type of the map, incremented with \c ++ operator, and 2969 /// if the iterator leaves the last valid item, it will be equal to 2970 /// \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 the 2984 /// 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 a 3043 /// 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 to 3045 /// the value (\c ItemIt), and the values of the map can be accessed 3046 /// with an STL compatible forward iterator (\c ValueIt). 3047 /// The map stores a linked list for each value, which contains 3048 /// the items mapped to the value, and the used values are stored 3049 /// in balanced binary tree (\c std::map). 3050 /// 3051 /// \ref IterableBoolMap and \ref IterableIntMap are similar classes 3052 /// specialized for \c bool and \c int values, respectively. 3053 /// 3054 /// This type is not reference map, so it cannot be modified with 3055 /// 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 or 3059 /// \c GR::Edge). 3060 /// \tparam V The value type of the map. It can be any comparable 3061 /// value type. 3062 /// 3063 /// \see IterableBoolMap, IterableIntMap 3064 /// \see CrossRefMap 3065 template <typename GR, typename K, typename V> 3066 class IterableValueMap 3067 : 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 type 3074 typedef K Key; 3075 /// The value type 3076 typedef V Value; 3077 /// The graph type 3078 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 forward 3132 /// iterator on the values of the map. The values can 3133 /// be accessed in the <tt>[beginValue, endValue)</tt> range. 3134 class ValueIt 3135 : 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 /// Constructor 3143 ValueIt() {} 3144 3145 /// \e 3146 ValueIt& operator++() { ++it; return *this; } 3147 /// \e 3148 ValueIt operator++(int) { 3149 ValueIt tmp(*this); 3150 operator++(); 3151 return tmp; 3152 } 3153 3154 /// \e 3155 const Value& operator*() const { return it->first; } 3156 /// \e 3157 const Value* operator->() const { return &(it->first); } 3158 3159 /// \e 3160 bool operator==(ValueIt jt) const { return it == jt.it; } 3161 /// \e 3162 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 the 3171 /// first value of the map. The values of the 3172 /// 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 the 3181 /// last value of the map. The values of the 3182 /// 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 works 3207 /// like a graph item iterator, it can be converted to 3208 /// the item type of the map, incremented with \c ++ operator, and 3209 /// if the iterator leaves the last valid item, it will be equal to 3210 /// \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 the 3224 /// keys which have the given value. 3225 /// \param map The IterableValueMap 3226 /// \param value The value 3227 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; 2312 3291 }; 2313 3292 … … 2322 3301 public: 2323 3302 2324 /// \e3303 /// The key type (the \c Arc type of the digraph). 2325 3304 typedef typename GR::Arc Key; 2326 /// \e3305 /// The value type (the \c Node type of the digraph). 2327 3306 typedef typename GR::Node Value; 2328 3307 … … 2363 3342 public: 2364 3343 2365 /// \e3344 /// The key type (the \c Arc type of the digraph). 2366 3345 typedef typename GR::Arc Key; 2367 /// \e3346 /// The value type (the \c Node type of the digraph). 2368 3347 typedef typename GR::Node Value; 2369 3348 … … 2405 3384 public: 2406 3385 3386 /// The key type (the \c Edge type of the digraph). 3387 typedef typename GR::Edge Key; 3388 /// The value type (the \c Arc type of the digraph). 2407 3389 typedef typename GR::Arc Value; 2408 typedef typename GR::Edge Key;2409 3390 2410 3391 /// \brief Constructor … … 2445 3426 public: 2446 3427 3428 /// The key type (the \c Edge type of the digraph). 3429 typedef typename GR::Edge Key; 3430 /// The value type (the \c Arc type of the digraph). 2447 3431 typedef typename GR::Arc Value; 2448 typedef typename GR::Edge Key;2449 3432 2450 3433 /// \brief Constructor … … 2481 3464 /// whenever the digraph changes. 2482 3465 /// 2483 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 3466 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 2484 3467 /// may provide alternative ways to modify the digraph. 2485 3468 /// The correct behavior of InDegMap is not guarantied if these additional … … 2497 3480 2498 3481 public: 2499 3482 2500 3483 /// The graph type of InDegMap 2501 3484 typedef GR Graph; … … 2611 3594 /// whenever the digraph changes. 2612 3595 /// 2613 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 3596 /// \warning Besides \c addNode() and \c addArc(), a digraph structure 2614 3597 /// may provide alternative ways to modify the digraph. 2615 3598 /// The correct behavior of OutDegMap is not guarantied if these additional … … 2782 3765 } 2783 3766 3767 3768 /// \brief Copy the values of a graph map to another map. 3769 /// 3770 /// This function copies the values of a graph map to another graph map. 3771 /// \c To::Key must be equal or convertible to \c From::Key and 3772 /// \c From::Value must be equal or convertible to \c To::Value. 3773 /// 3774 /// For example, an edge map of \c int value type can be copied to 3775 /// an arc map of \c double value type in an undirected graph, but 3776 /// an arc map cannot be copied to an edge map. 3777 /// Note that even a \ref ConstMap can be copied to a standard graph map, 3778 /// but \ref mapFill() can also be used for this purpose. 3779 /// 3780 /// \param gr The graph for which the maps are defined. 3781 /// \param from The map from which the values have to be copied. 3782 /// It must conform to the \ref concepts::ReadMap "ReadMap" concept. 3783 /// \param to The map to which the values have to be copied. 3784 /// It must conform to the \ref concepts::WriteMap "WriteMap" concept. 3785 template <typename GR, typename From, typename To> 3786 void mapCopy(const GR& gr, const From& from, To& to) { 3787 typedef typename To::Key Item; 3788 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 3789 3790 for (ItemIt it(gr); it != INVALID; ++it) { 3791 to.set(it, from[it]); 3792 } 3793 } 3794 3795 /// \brief Compare two graph maps. 3796 /// 3797 /// This function compares the values of two graph maps. It returns 3798 /// \c true if the maps assign the same value for all items in the graph. 3799 /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal 3800 /// and their \c Value types must be comparable using \c %operator==(). 3801 /// 3802 /// \param gr The graph for which the maps are defined. 3803 /// \param map1 The first map. 3804 /// \param map2 The second map. 3805 template <typename GR, typename Map1, typename Map2> 3806 bool mapCompare(const GR& gr, const Map1& map1, const Map2& map2) { 3807 typedef typename Map2::Key Item; 3808 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 3809 3810 for (ItemIt it(gr); it != INVALID; ++it) { 3811 if (!(map1[it] == map2[it])) return false; 3812 } 3813 return true; 3814 } 3815 3816 /// \brief Return an item having minimum value of a graph map. 3817 /// 3818 /// This function returns an item (\c Node, \c Arc or \c Edge) having 3819 /// minimum value of the given graph map. 3820 /// If the item set is empty, it returns \c INVALID. 3821 /// 3822 /// \param gr The graph for which the map is defined. 3823 /// \param map The graph map. 3824 template <typename GR, typename Map> 3825 typename Map::Key mapMin(const GR& gr, const Map& map) { 3826 return mapMin(gr, map, std::less<typename Map::Value>()); 3827 } 3828 3829 /// \brief Return an item having minimum value of a graph map. 3830 /// 3831 /// This function returns an item (\c Node, \c Arc or \c Edge) having 3832 /// minimum value of the given graph map. 3833 /// If the item set is empty, it returns \c INVALID. 3834 /// 3835 /// \param gr The graph for which the map is defined. 3836 /// \param map The graph map. 3837 /// \param comp Comparison function object. 3838 template <typename GR, typename Map, typename Comp> 3839 typename Map::Key mapMin(const GR& gr, const Map& map, const Comp& comp) { 3840 typedef typename Map::Key Item; 3841 typedef typename Map::Value Value; 3842 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 3843 3844 ItemIt min_item(gr); 3845 if (min_item == INVALID) return INVALID; 3846 Value min = map[min_item]; 3847 for (ItemIt it(gr); it != INVALID; ++it) { 3848 if (comp(map[it], min)) { 3849 min = map[it]; 3850 min_item = it; 3851 } 3852 } 3853 return min_item; 3854 } 3855 3856 /// \brief Return an item having maximum value of a graph map. 3857 /// 3858 /// This function returns an item (\c Node, \c Arc or \c Edge) having 3859 /// maximum value of the given graph map. 3860 /// If the item set is empty, it returns \c INVALID. 3861 /// 3862 /// \param gr The graph for which the map is defined. 3863 /// \param map The graph map. 3864 template <typename GR, typename Map> 3865 typename Map::Key mapMax(const GR& gr, const Map& map) { 3866 return mapMax(gr, map, std::less<typename Map::Value>()); 3867 } 3868 3869 /// \brief Return an item having maximum value of a graph map. 3870 /// 3871 /// This function returns an item (\c Node, \c Arc or \c Edge) having 3872 /// maximum value of the given graph map. 3873 /// If the item set is empty, it returns \c INVALID. 3874 /// 3875 /// \param gr The graph for which the map is defined. 3876 /// \param map The graph map. 3877 /// \param comp Comparison function object. 3878 template <typename GR, typename Map, typename Comp> 3879 typename Map::Key mapMax(const GR& gr, const Map& map, const Comp& comp) { 3880 typedef typename Map::Key Item; 3881 typedef typename Map::Value Value; 3882 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 3883 3884 ItemIt max_item(gr); 3885 if (max_item == INVALID) return INVALID; 3886 Value max = map[max_item]; 3887 for (ItemIt it(gr); it != INVALID; ++it) { 3888 if (comp(max, map[it])) { 3889 max = map[it]; 3890 max_item = it; 3891 } 3892 } 3893 return max_item; 3894 } 3895 3896 /// \brief Return the minimum value of a graph map. 3897 /// 3898 /// This function returns the minimum value of the given graph map. 3899 /// The corresponding item set of the graph must not be empty. 3900 /// 3901 /// \param gr The graph for which the map is defined. 3902 /// \param map The graph map. 3903 template <typename GR, typename Map> 3904 typename Map::Value mapMinValue(const GR& gr, const Map& map) { 3905 return map[mapMin(gr, map, std::less<typename Map::Value>())]; 3906 } 3907 3908 /// \brief Return the minimum value of a graph map. 3909 /// 3910 /// This function returns the minimum value of the given graph map. 3911 /// The corresponding item set of the graph must not be empty. 3912 /// 3913 /// \param gr The graph for which the map is defined. 3914 /// \param map The graph map. 3915 /// \param comp Comparison function object. 3916 template <typename GR, typename Map, typename Comp> 3917 typename Map::Value 3918 mapMinValue(const GR& gr, const Map& map, const Comp& comp) { 3919 return map[mapMin(gr, map, comp)]; 3920 } 3921 3922 /// \brief Return the maximum value of a graph map. 3923 /// 3924 /// This function returns the maximum value of the given graph map. 3925 /// The corresponding item set of the graph must not be empty. 3926 /// 3927 /// \param gr The graph for which the map is defined. 3928 /// \param map The graph map. 3929 template <typename GR, typename Map> 3930 typename Map::Value mapMaxValue(const GR& gr, const Map& map) { 3931 return map[mapMax(gr, map, std::less<typename Map::Value>())]; 3932 } 3933 3934 /// \brief Return the maximum value of a graph map. 3935 /// 3936 /// This function returns the maximum value of the given graph map. 3937 /// The corresponding item set of the graph must not be empty. 3938 /// 3939 /// \param gr The graph for which the map is defined. 3940 /// \param map The graph map. 3941 /// \param comp Comparison function object. 3942 template <typename GR, typename Map, typename Comp> 3943 typename Map::Value 3944 mapMaxValue(const GR& gr, const Map& map, const Comp& comp) { 3945 return map[mapMax(gr, map, comp)]; 3946 } 3947 3948 /// \brief Return an item having a specified value in a graph map. 3949 /// 3950 /// This function returns an item (\c Node, \c Arc or \c Edge) having 3951 /// the specified assigned value in the given graph map. 3952 /// If no such item exists, it returns \c INVALID. 3953 /// 3954 /// \param gr The graph for which the map is defined. 3955 /// \param map The graph map. 3956 /// \param val The value that have to be found. 3957 template <typename GR, typename Map> 3958 typename Map::Key 3959 mapFind(const GR& gr, const Map& map, const typename Map::Value& val) { 3960 typedef typename Map::Key Item; 3961 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 3962 3963 for (ItemIt it(gr); it != INVALID; ++it) { 3964 if (map[it] == val) return it; 3965 } 3966 return INVALID; 3967 } 3968 3969 /// \brief Return an item having value for which a certain predicate is 3970 /// true in a graph map. 3971 /// 3972 /// This function returns an item (\c Node, \c Arc or \c Edge) having 3973 /// such assigned value for which the specified predicate is true 3974 /// in the given graph map. 3975 /// If no such item exists, it returns \c INVALID. 3976 /// 3977 /// \param gr The graph for which the map is defined. 3978 /// \param map The graph map. 3979 /// \param pred The predicate function object. 3980 template <typename GR, typename Map, typename Pred> 3981 typename Map::Key 3982 mapFindIf(const GR& gr, const Map& map, const Pred& pred) { 3983 typedef typename Map::Key Item; 3984 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 3985 3986 for (ItemIt it(gr); it != INVALID; ++it) { 3987 if (pred(map[it])) return it; 3988 } 3989 return INVALID; 3990 } 3991 3992 /// \brief Return the number of items having a specified value in a 3993 /// graph map. 3994 /// 3995 /// This function returns the number of items (\c Node, \c Arc or \c Edge) 3996 /// having the specified assigned value in the given graph map. 3997 /// 3998 /// \param gr The graph for which the map is defined. 3999 /// \param map The graph map. 4000 /// \param val The value that have to be counted. 4001 template <typename GR, typename Map> 4002 int mapCount(const GR& gr, const Map& map, const typename Map::Value& val) { 4003 typedef typename Map::Key Item; 4004 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 4005 4006 int cnt = 0; 4007 for (ItemIt it(gr); it != INVALID; ++it) { 4008 if (map[it] == val) ++cnt; 4009 } 4010 return cnt; 4011 } 4012 4013 /// \brief Return the number of items having values for which a certain 4014 /// predicate is true in a graph map. 4015 /// 4016 /// This function returns the number of items (\c Node, \c Arc or \c Edge) 4017 /// having such assigned values for which the specified predicate is true 4018 /// in the given graph map. 4019 /// 4020 /// \param gr The graph for which the map is defined. 4021 /// \param map The graph map. 4022 /// \param pred The predicate function object. 4023 template <typename GR, typename Map, typename Pred> 4024 int mapCountIf(const GR& gr, const Map& map, const Pred& pred) { 4025 typedef typename Map::Key Item; 4026 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 4027 4028 int cnt = 0; 4029 for (ItemIt it(gr); it != INVALID; ++it) { 4030 if (pred(map[it])) ++cnt; 4031 } 4032 return cnt; 4033 } 4034 4035 /// \brief Fill a graph map with a certain value. 4036 /// 4037 /// This function sets the specified value for all items (\c Node, 4038 /// \c Arc or \c Edge) in the given graph map. 4039 /// 4040 /// \param gr The graph for which the map is defined. 4041 /// \param map The graph map. It must conform to the 4042 /// \ref concepts::WriteMap "WriteMap" concept. 4043 /// \param val The value. 4044 template <typename GR, typename Map> 4045 void mapFill(const GR& gr, Map& map, const typename Map::Value& val) { 4046 typedef typename Map::Key Item; 4047 typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt; 4048 4049 for (ItemIt it(gr); it != INVALID; ++it) { 4050 map.set(it, val); 4051 } 4052 } 4053 2784 4054 /// @} 2785 4055 } -
lemon/min_cost_arborescence.h
r672 r760 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 morecontrol on the execution,492 /// first you must call \ref init(), then you can add several491 /// If you need better control on the execution, 492 /// you have to call \ref init() first, 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
r710 r802 41 41 /// 42 42 /// \ref NetworkSimplex implements the primal Network Simplex algorithm 43 /// for finding a \ref min_cost_flow "minimum cost flow". 43 /// for finding a \ref min_cost_flow "minimum cost flow" 44 /// \ref amo93networkflows, \ref dantzig63linearprog, 45 /// \ref kellyoneill91netsimplex. 44 46 /// This algorithm is a specialized version of the linear programming 45 47 /// simplex method directly for the minimum cost flow problem. … … 162 164 TEMPLATE_DIGRAPH_TYPEDEFS(GR); 163 165 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 , min_arc = _next_arc;367 int e; 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 min_arc = e;372 _in_arc = e; 373 373 } 374 374 if (--cnt == 0) { 375 if (min < 0) break;375 if (min < 0) goto search_end; 376 376 cnt = _block_size; 377 377 } 378 378 } 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 } 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; 390 388 } 391 389 } 392 390 if (min >= 0) return false; 393 _in_arc = min_arc; 391 392 search_end: 394 393 _next_arc = e; 395 394 return true; … … 429 428 { 430 429 // The main parameters of the pivot rule 431 const double LIST_LENGTH_FACTOR = 1.0;430 const double LIST_LENGTH_FACTOR = 0.25; 432 431 const int MIN_LIST_LENGTH = 10; 433 432 const double MINOR_LIMIT_FACTOR = 0.1; … … 446 445 bool findEnteringArc() { 447 446 Cost min, c; 448 int e , min_arc = _next_arc;447 int e; 449 448 if (_curr_length > 0 && _minor_count < _minor_limit) { 450 449 // Minor iteration: select the best eligible arc from the … … 457 456 if (c < min) { 458 457 min = c; 459 min_arc = e;458 _in_arc = e; 460 459 } 461 if (c >= 0) {460 else if (c >= 0) { 462 461 _candidates[i--] = _candidates[--_curr_length]; 463 462 } 464 463 } 465 if (min < 0) { 466 _in_arc = min_arc; 467 return true; 468 } 464 if (min < 0) return true; 469 465 } 470 466 … … 478 474 if (c < min) { 479 475 min = c; 480 min_arc = e;476 _in_arc = e; 481 477 } 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; 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; 495 488 } 489 if (_curr_length == _list_length) goto search_end; 496 490 } 497 491 } 498 492 if (_curr_length == 0) return false; 493 494 search_end: 499 495 _minor_count = 1; 500 _in_arc = min_arc;501 496 _next_arc = e; 502 497 return true; … … 550 545 { 551 546 // The main parameters of the pivot rule 552 const double BLOCK_SIZE_FACTOR = 1. 5;547 const double BLOCK_SIZE_FACTOR = 1.0; 553 548 const int MIN_BLOCK_SIZE = 10; 554 549 const double HEAD_LENGTH_FACTOR = 0.1; … … 579 574 // Extend the list 580 575 int cnt = _block_size; 581 int last_arc = 0;582 576 int limit = _head_length; 583 577 584 for ( inte = _next_arc; e < _search_arc_num; ++e) {578 for (e = _next_arc; e < _search_arc_num; ++e) { 585 579 _cand_cost[e] = _state[e] * 586 580 (_cost[e] + _pi[_source[e]] - _pi[_target[e]]); 587 581 if (_cand_cost[e] < 0) { 588 582 _candidates[_curr_length++] = e; 589 last_arc = e;590 583 } 591 584 if (--cnt == 0) { 592 if (_curr_length > limit) break;585 if (_curr_length > limit) goto search_end; 593 586 limit = 0; 594 587 cnt = _block_size; 595 588 } 596 589 } 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 } 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; 610 600 } 611 601 } 612 602 if (_curr_length == 0) return false; 613 _next_arc = last_arc + 1; 603 604 search_end: 614 605 615 606 // Make heap of the candidate list (approximating a partial sort) … … 619 610 // Pop the first element of the heap 620 611 _in_arc = _candidates[0]; 612 _next_arc = e; 621 613 pop_heap( _candidates.begin(), _candidates.begin() + _curr_length, 622 614 _sort_func ); … … 634 626 /// 635 627 /// \param graph The digraph the algorithm runs on. 636 NetworkSimplex(const GR& graph) : 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) : 637 633 _graph(graph), _node_id(graph), _arc_id(graph), 638 634 INF(std::numeric_limits<Value>::has_infinity ? … … 672 668 _state.resize(max_arc_num); 673 669 674 // Copy the graph (store the arcs in a mixed order)670 // Copy the graph 675 671 int i = 0; 676 672 for (NodeIt n(_graph); n != INVALID; ++n, ++i) { 677 673 _node_id[n] = i; 678 674 } 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; 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 } 686 693 } 687 694 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; 695 // Reset parameters 696 reset(); 699 697 } 700 698 … … 769 767 /// If neither this function nor \ref stSupply() is used before 770 768 /// 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.)772 769 /// 773 770 /// \param map A node map storing the supply values. … … 790 787 /// If neither this function nor \ref supplyMap() is used before 791 788 /// 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.)793 789 /// 794 790 /// Using this function has the same effect as using \ref supplyMap() -
lemon/path.h
r606 r831 71 71 template <typename CPath> 72 72 Path(const CPath& cpath) { 73 copyPath(*this, cpath);73 pathCopy(cpath, *this); 74 74 } 75 75 … … 79 79 template <typename CPath> 80 80 Path& operator=(const CPath& cpath) { 81 copyPath(*this, cpath);81 pathCopy(cpath, *this); 82 82 return *this; 83 83 } … … 259 259 template <typename CPath> 260 260 SimplePath(const CPath& cpath) { 261 copyPath(*this, cpath);261 pathCopy(cpath, *this); 262 262 } 263 263 … … 268 268 template <typename CPath> 269 269 SimplePath& operator=(const CPath& cpath) { 270 copyPath(*this, cpath);270 pathCopy(cpath, *this); 271 271 return *this; 272 272 } … … 438 438 template <typename CPath> 439 439 ListPath(const CPath& cpath) : first(0), last(0) { 440 copyPath(*this, cpath);440 pathCopy(cpath, *this); 441 441 } 442 442 … … 454 454 template <typename CPath> 455 455 ListPath& operator=(const CPath& cpath) { 456 copyPath(*this, cpath);456 pathCopy(cpath, *this); 457 457 return *this; 458 458 } … … 764 764 template <typename CPath> 765 765 StaticPath(const CPath& cpath) : arcs(0) { 766 copyPath(*this, cpath);766 pathCopy(cpath, *this); 767 767 } 768 768 … … 780 780 template <typename CPath> 781 781 StaticPath& operator=(const CPath& cpath) { 782 copyPath(*this, cpath);782 pathCopy(cpath, *this); 783 783 return *this; 784 784 } … … 929 929 }; 930 930 931 template <typename Target, typename Source,932 bool buildEnable = BuildTagIndicator<T arget>::value>931 template <typename From, typename To, 932 bool buildEnable = BuildTagIndicator<To>::value> 933 933 struct PathCopySelectorForward { 934 static void copy( Target& target, const Source& source) {935 t arget.clear();936 for (typename Source::ArcIt it(source); it != INVALID; ++it) {937 t arget.addBack(it);934 static void copy(const From& from, To& to) { 935 to.clear(); 936 for (typename From::ArcIt it(from); it != INVALID; ++it) { 937 to.addBack(it); 938 938 } 939 939 } 940 940 }; 941 941 942 template <typename Target, typename Source>943 struct PathCopySelectorForward< Target, Source, true> {944 static void copy( Target& target, const Source& source) {945 t arget.clear();946 t arget.build(source);947 } 948 }; 949 950 template <typename Target, typename Source,951 bool buildEnable = BuildTagIndicator<T arget>::value>942 template <typename From, typename To> 943 struct PathCopySelectorForward<From, To, true> { 944 static void copy(const From& from, To& to) { 945 to.clear(); 946 to.build(from); 947 } 948 }; 949 950 template <typename From, typename To, 951 bool buildEnable = BuildTagIndicator<To>::value> 952 952 struct PathCopySelectorBackward { 953 static void copy( Target& target, const Source& source) {954 t arget.clear();955 for (typename Source::RevArcIt it(source); it != INVALID; ++it) {956 t arget.addFront(it);953 static void copy(const From& from, To& to) { 954 to.clear(); 955 for (typename From::RevArcIt it(from); it != INVALID; ++it) { 956 to.addFront(it); 957 957 } 958 958 } 959 959 }; 960 960 961 template <typename Target, typename Source>962 struct PathCopySelectorBackward< Target, Source, true> {963 static void copy( Target& target, const Source& source) {964 t arget.clear();965 t arget.buildRev(source);961 template <typename From, typename To> 962 struct PathCopySelectorBackward<From, To, true> { 963 static void copy(const From& from, To& to) { 964 to.clear(); 965 to.buildRev(from); 966 966 } 967 967 }; 968 968 969 969 970 template <typename Target, typename Source,971 bool revEnable = RevPathTagIndicator< Source>::value>970 template <typename From, typename To, 971 bool revEnable = RevPathTagIndicator<From>::value> 972 972 struct PathCopySelector { 973 static void copy( Target& target, const Source& source) {974 PathCopySelectorForward< Target, Source>::copy(target, source);973 static void copy(const From& from, To& to) { 974 PathCopySelectorForward<From, To>::copy(from, to); 975 975 } 976 976 }; 977 977 978 template <typename Target, typename Source>979 struct PathCopySelector< Target, Source, true> {980 static void copy( Target& target, const Source& source) {981 PathCopySelectorBackward< Target, Source>::copy(target, source);978 template <typename From, typename To> 979 struct PathCopySelector<From, To, true> { 980 static void copy(const From& from, To& to) { 981 PathCopySelectorBackward<From, To>::copy(from, to); 982 982 } 983 983 }; … … 988 988 /// \brief Make a copy of a path. 989 989 /// 990 /// This function makes a copy of a path. 991 template <typename Target, typename Source> 992 void copyPath(Target& target, const Source& source) { 993 checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>(); 994 _path_bits::PathCopySelector<Target, Source>::copy(target, source); 990 /// This function makes a copy of a path. 991 template <typename From, typename To> 992 void pathCopy(const From& from, To& to) { 993 checkConcept<concepts::PathDumper<typename From::Digraph>, From>(); 994 _path_bits::PathCopySelector<From, To>::copy(from, to); 995 } 996 997 /// \brief Deprecated version of \ref pathCopy(). 998 /// 999 /// Deprecated version of \ref pathCopy() (only for reverse compatibility). 1000 template <typename To, typename From> 1001 void copyPath(To& to, const From& from) { 1002 pathCopy(from, to); 995 1003 } 996 1004 … … 1016 1024 /// \brief The source of a path 1017 1025 /// 1018 /// This function returns the source of the given path. 1026 /// This function returns the source node of the given path. 1027 /// If the path is empty, then it returns \c INVALID. 1019 1028 template <typename Digraph, typename Path> 1020 1029 typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) { 1021 return digraph.source(path.front());1030 return path.empty() ? INVALID : digraph.source(path.front()); 1022 1031 } 1023 1032 1024 1033 /// \brief The target of a path 1025 1034 /// 1026 /// This function returns the target of the given path. 1035 /// This function returns the target node of the given path. 1036 /// If the path is empty, then it returns \c INVALID. 1027 1037 template <typename Digraph, typename Path> 1028 1038 typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) { 1029 return digraph.target(path.back());1039 return path.empty() ? INVALID : digraph.target(path.back()); 1030 1040 } 1031 1041 -
lemon/preflow.h
r688 r802 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 DOXYGEN 56 typedef GR::ArcMap<Value> FlowMap; 57 #else 55 58 typedef typename Digraph::template ArcMap<Value> FlowMap; 59 #endif 56 60 57 61 /// \brief Instantiates a FlowMap. … … 68 72 /// The elevator type used by Preflow algorithm. 69 73 /// 70 /// \sa Elevator 71 /// \sa LinkedElevator 72 typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator; 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 73 80 74 81 /// \brief Instantiates an Elevator. … … 96 103 /// This class provides an implementation of Goldberg-Tarjan's \e preflow 97 104 /// \e push-relabel algorithm producing a \ref max_flow 98 /// "flow of maximum value" in a digraph. 105 /// "flow of maximum value" in a digraph \ref clrs01algorithms, 106 /// \ref amo93networkflows, \ref goldberg88newapproach. 99 107 /// The preflow algorithms are the fastest known maximum 100 /// flow algorithms. The current implementation use a mixture of the108 /// flow algorithms. The current implementation uses a mixture of the 101 109 /// \e "highest label" and the \e "bound decrease" heuristics. 102 110 /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$. … … 372 380 } 373 381 374 /// \brief Sets the tolerance used by algorithm. 375 /// 376 /// Sets the tolerance used by algorithm. 377 Preflow& tolerance(const Tolerance& tolerance) const { 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) { 378 387 _tolerance = tolerance; 379 388 return *this; … … 382 391 /// \brief Returns a const reference to the tolerance. 383 392 /// 384 /// Returns a const reference to the tolerance. 393 /// Returns a const reference to the tolerance object used by 394 /// the algorithm. 385 395 const Tolerance& tolerance() const { 386 return tolerance;396 return _tolerance; 387 397 } 388 398 … … 390 400 /// The simplest way to execute the preflow algorithm is to use 391 401 /// \ref run() or \ref runMinCut().\n 392 /// If you need morecontrol on the initial solution or the execution,393 /// first you have to call one of the \ref init() functions, then402 /// If you need better control on the initial solution or the execution, 403 /// you have to call one of the \ref init() functions first, then 394 404 /// \ref startFirstPhase() and if you need it \ref startSecondPhase(). 395 405 -
lemon/radix_heap.h
r730 r758 20 20 #define LEMON_RADIX_HEAP_H 21 21 22 ///\ingroup auxdat22 ///\ingroup heaps 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 auxdata32 /// \ingroup heaps 33 33 /// 34 /// \brief A Radix Heap implementation.34 /// \brief Radix heap data structure. 35 35 /// 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. 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. 43 41 /// 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 42 /// \tparam IM A read-writable item map with \c int values, used 43 /// internally to handle the cross references. 49 44 template <typename IM> 50 45 class RadixHeap { 51 46 52 47 public: 53 typedef typename IM::Key Item; 48 49 /// Type of the item-int map. 50 typedef IM ItemIntMap; 51 /// Type of the priorities. 54 52 typedef int Prio; 55 typedef IM ItemIntMap; 53 /// Type of the items stored in the heap. 54 typedef typename ItemIntMap::Key Item; 56 55 57 56 /// \brief Exception thrown by RadixHeap. 58 57 /// 59 /// This Exception is thrown when a smaller priority60 /// is inserted into the \e RadixHeap then the last time erased.58 /// This exception is thrown when an item is inserted into a 59 /// RadixHeap with a priority smaller than the last erased one. 61 60 /// \see RadixHeap 62 63 class UnderFlowPriorityError : public Exception { 61 class PriorityUnderflowError : public Exception { 64 62 public: 65 63 virtual const char* what() const throw() { 66 return "lemon::RadixHeap:: UnderFlowPriorityError";64 return "lemon::RadixHeap::PriorityUnderflowError"; 67 65 } 68 66 }; 69 67 70 /// \brief Type to represent the items states.71 /// 72 /// Each Item element have a state associated to it. It maybe "in heap",73 /// "pre heap" or "postheap". The latter two are indifferent from the68 /// \brief Type to represent the states of the items. 69 /// 70 /// Each item has a state associated to it. It can be "in heap", 71 /// "pre-heap" or "post-heap". The latter two are indifferent from the 74 72 /// heap's point of view, but may be useful to the user. 75 73 /// 76 /// The ItemIntMap \e should be initialized in such way that it maps77 /// PRE_HEAP (-1) to any element to be put in the heap...74 /// The item-int map must be initialized in such way that it assigns 75 /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap. 78 76 enum State { 79 IN_HEAP = 0, 80 PRE_HEAP = -1, 81 POST_HEAP = -2 77 IN_HEAP = 0, ///< = 0. 78 PRE_HEAP = -1, ///< = -1. 79 POST_HEAP = -2 ///< = -2. 82 80 }; 83 81 … … 97 95 }; 98 96 99 std::vector<RadixItem> data;100 std::vector<RadixBox> boxes;97 std::vector<RadixItem> _data; 98 std::vector<RadixBox> _boxes; 101 99 102 100 ItemIntMap &_iim; 103 101 104 105 102 public: 106 /// \brief The constructor. 107 /// 108 /// The constructor.109 /// 110 /// \param map It should be given to the constructor, since it is used111 /// internally to handle the cross references. The value of the map112 /// should be PRE_HEAP (-1) for each element.113 /// 114 /// \param minimal The initial minimal valueof 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)) {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 capacity of 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)) { 121 118 extend(); 122 119 } 123 120 } 124 121 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)) { 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)) { 145 146 extend(); 146 147 } … … 150 151 151 152 bool upper(int box, Prio pr) { 152 return pr < boxes[box].min;153 return pr < _boxes[box].min; 153 154 } 154 155 155 156 bool lower(int box, Prio pr) { 156 return pr >= boxes[box].min +boxes[box].size;157 } 158 159 // / \brief Remove item from the box list.157 return pr >= _boxes[box].min + _boxes[box].size; 158 } 159 160 // Remove item from the box list 160 161 void remove(int index) { 161 if ( data[index].prev >= 0) {162 data[data[index].prev].next =data[index].next;162 if (_data[index].prev >= 0) { 163 _data[_data[index].prev].next = _data[index].next; 163 164 } else { 164 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.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 list 172 173 void insert(int box, int index) { 173 if ( boxes[box].first == -1) {174 boxes[box].first = index;175 data[index].next =data[index].prev = -1;174 if (_boxes[box].first == -1) { 175 _boxes[box].first = index; 176 _data[index].next = _data[index].prev = -1; 176 177 } else { 177 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.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 list 186 187 void extend() { 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 // / \briefMove an item up into the proper box.193 void bubble _up(int index) {194 if (!lower( data[index].box,data[index].prio)) return;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 bubbleUp(int index) { 195 if (!lower(_data[index].box, _data[index].prio)) return; 195 196 remove(index); 196 int box = findUp( data[index].box,data[index].prio);197 int box = findUp(_data[index].box, _data[index].prio); 197 198 insert(box, index); 198 199 } 199 200 200 // / \brief Find up the proper box for the item with the given prio.201 // Find up the proper box for the item with the given priority 201 202 int findUp(int start, int pr) { 202 203 while (lower(start, pr)) { 203 if (++start == int( boxes.size())) {204 if (++start == int(_boxes.size())) { 204 205 extend(); 205 206 } … … 208 209 } 209 210 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;211 // Move an item down into the proper box 212 void bubbleDown(int index) { 213 if (!upper(_data[index].box, _data[index].prio)) return; 213 214 remove(index); 214 int box = findDown( data[index].box,data[index].prio);215 int box = findDown(_data[index].box, _data[index].prio); 215 216 insert(box, index); 216 217 } 217 218 218 // / \brief Find up the proper box for the item with the given prio.219 // Find down the proper box for the item with the given priority 219 220 int findDown(int start, int pr) { 220 221 while (upper(start, pr)) { 221 if (--start < 0) throw UnderFlowPriorityError();222 if (--start < 0) throw PriorityUnderflowError(); 222 223 } 223 224 return start; 224 225 } 225 226 226 // / \brief Find the first not empty box.227 // Find the first non-empty box 227 228 int findFirst() { 228 229 int first = 0; 229 while ( boxes[first].first == -1) ++first;230 while (_boxes[first].first == -1) ++first; 230 231 return first; 231 232 } 232 233 233 // / \brief Gives back the minimal prio of the box.234 // Gives back the minimum priority of the given box 234 235 int minValue(int box) { 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;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; 238 239 } 239 240 return min; 240 241 } 241 242 242 /// \brief Rearrange the items of the heap and makes the 243 /// first box not empty. 243 // Rearrange the items of the heap and make the first box non-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 bubbleDown(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 relocateLast(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 /// Adds \c i to the heap with priority \c p. 280 /// This function inserts the given item into the heap with the 281 /// given priority. 281 282 /// \param i The item to insert. 282 283 /// \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. 283 286 void push(const Item &i, const Prio &p) { 284 int n = data.size();287 int n = _data.size(); 285 288 _iim.set(i, n); 286 data.push_back(RadixItem(i, p));287 while (lower( boxes.size() - 1, p)) {289 _data.push_back(RadixItem(i, p)); 290 while (lower(_boxes.size() - 1, p)) { 288 291 extend(); 289 292 } 290 int box = findDown( boxes.size() - 1, p);293 int box = findDown(_boxes.size() - 1, p); 291 294 insert(box, n); 292 295 } 293 296 294 /// \brief Return s the item withminimum priority.295 /// 296 /// This method returns the item withminimum priority.297 /// \pre The heap must be non empty.297 /// \brief Return the item having minimum priority. 298 /// 299 /// This function returns the item having minimum priority. 300 /// \pre The heap must be non-empty. 298 301 Item top() const { 299 302 const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown(); 300 return data[boxes[0].first].item;301 } 302 303 /// \brief Returns the minimum priority.304 /// 305 /// Itreturns the minimum priority.306 /// \pre The heap must be non empty.303 return _data[_boxes[0].first].item; 304 } 305 306 /// \brief The minimum priority. 307 /// 308 /// This function returns the minimum priority. 309 /// \pre The heap must be non-empty. 307 310 Prio prio() const { 308 311 const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown(); 309 return data[boxes[0].first].prio;312 return _data[_boxes[0].first].prio; 310 313 } 311 314 312 /// \brief Deletes the item withminimum priority.313 /// 314 /// This method deletes the item withminimum priority.315 /// \brief Remove the item having minimum priority. 316 /// 317 /// This function removes the item having minimum priority. 315 318 /// \pre The heap must be non-empty. 316 319 void pop() { 317 320 moveDown(); 318 int index = boxes[0].first;319 _iim[ data[index].item] = POST_HEAP;321 int index = _boxes[0].first; 322 _iim[_data[index].item] = POST_HEAP; 320 323 remove(index); 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. 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. 329 333 void erase(const Item &i) { 330 334 int index = _iim[i]; 331 335 _iim[i] = POST_HEAP; 332 336 remove(index); 333 relocate _last(index);337 relocateLast(index); 334 338 } 335 339 336 /// \brief Returns the priority of \c i.337 /// 338 /// This function returns the priority of item \c i.339 /// \p re \c i must be in the heap.340 /// \p aram i The item.340 /// \brief The priority of the given item. 341 /// 342 /// This function returns the priority of the given item. 343 /// \param i The item. 344 /// \pre \e i must be in the heap. 341 345 Prio operator[](const Item &i) const { 342 346 int idx = _iim[i]; 343 return data[idx].prio;344 } 345 346 /// \brief \c i gets to the heap with priority \c p independently347 /// if \c i was already there.348 /// 349 /// This method calls \ref push(\c i, \c p) if \c i is not stored350 /// in the heap and sets the priority of \c i to \c p otherwise.351 /// It may throw an \e UnderFlowPriorityException.347 return _data[idx].prio; 348 } 349 350 /// \brief Set the priority of an item or insert it, if it is 351 /// not stored in the heap. 352 /// 353 /// This method sets the priority of the given item if it is 354 /// already stored in the heap. Otherwise it inserts the given 355 /// item into the heap with the given priority. 352 356 /// \param i The item. 353 357 /// \param p The priority. 358 /// \pre \e i must be in the heap. 359 /// \warning This method may throw an \c UnderFlowPriorityException. 354 360 void set(const Item &i, const Prio &p) { 355 361 int idx = _iim[i]; … … 357 363 push(i, p); 358 364 } 359 else if( p >= data[idx].prio ) {360 data[idx].prio = p;361 bubble _up(idx);365 else if( p >= _data[idx].prio ) { 366 _data[idx].prio = p; 367 bubbleUp(idx); 362 368 } else { 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. 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. 374 377 /// \param i The item. 375 378 /// \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. 376 381 void decrease(const Item &i, const Prio &p) { 377 382 int idx = _iim[i]; 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 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. 386 390 /// \param i The item. 387 391 /// \param p The priority. 392 /// \pre \e i must be stored in the heap with priority at most \e p. 388 393 void increase(const Item &i, const Prio &p) { 389 394 int idx = _iim[i]; 390 data[idx].prio = p;391 bubble _up(idx);392 } 393 394 /// \brief Return s if \c item is in, has already been in, or has395 /// never been in the heap.396 /// 397 /// This method returns PRE_HEAP if \c item has never been in the398 /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP399 /// otherwise. In the latter case it is possible that \c item will400 /// get backto the heap again.395 _data[idx].prio = p; 396 bubbleUp(idx); 397 } 398 399 /// \brief Return the state of an item. 400 /// 401 /// This method returns \c PRE_HEAP if the given item has never 402 /// 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 back 405 /// to the heap again. 401 406 /// \param i The item. 402 407 State state(const Item &i) const { … … 406 411 } 407 412 408 /// \brief Set s the state of the \citem in the heap.409 /// 410 /// Sets the state of the \c item in the heap. It can be used to411 /// manually clear the heap when it is important to achive the412 /// better time complexity.413 /// \brief Set the state of an item 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 important 417 /// to achive better time complexity. 413 418 /// \param i The item. 414 419 /// \param st The state. It should not be \c IN_HEAP. -
lemon/smart_graph.h
r664 r827 33 33 34 34 class SmartDigraph; 35 ///Base of SmartDigraph 36 37 ///Base of SmartDigraph 38 /// 35 39 36 class SmartDigraphBase { 40 37 protected: … … 188 185 ///\brief A smart directed graph class. 189 186 /// 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". 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). 195 191 /// 196 ///\sa concepts::Digraph. 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 197 199 class SmartDigraph : public ExtendedSmartDigraphBase { 198 200 typedef ExtendedSmartDigraphBase Parent; 199 201 200 202 private: 201 202 ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. 203 204 ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead. 205 /// 203 /// Digraphs are \e not copy constructible. Use DigraphCopy instead. 206 204 SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {}; 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. 205 /// \brief Assignment of a digraph to another one is \e not allowed. 206 /// Use DigraphCopy instead. 212 207 void operator=(const SmartDigraph &) {} 213 208 … … 222 217 ///Add a new node to the digraph. 223 218 224 /// Adda new node to the digraph.225 /// 219 ///This function adds a new node to the digraph. 220 ///\return The new node. 226 221 Node addNode() { return Parent::addNode(); } 227 222 228 223 ///Add a new arc to the digraph. 229 224 230 /// Adda new arc to the digraph with source node \c s225 ///This function adds a new arc to the digraph with source node \c s 231 226 ///and target node \c t. 232 227 ///\return The new arc. 233 Arc addArc( const Node& s, const Node&t) {228 Arc addArc(Node s, Node t) { 234 229 return Parent::addArc(s, t); 235 230 } 236 231 237 /// \brief Using this it is possible to avoid the superfluous memory238 /// allocation.239 240 /// Using this it is possible to avoid the superfluous memory241 /// allocation: if you know that the digraph you want to build will242 /// 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 starting244 /// to build the digraph.245 /// \sa reserveArc246 void reserveNode(int n) { nodes.reserve(n); };247 248 /// \brief Using this it is possible to avoid the superfluous memory249 /// allocation.250 251 /// Using this it is possible to avoid the superfluous memory252 /// allocation: if you know that the digraph you want to build will253 /// 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 starting255 /// to build the digraph.256 /// \sa reserveNode257 void reserveArc(int m) { arcs.reserve(m); };258 259 232 /// \brief Node validity check 260 233 /// 261 /// This function gives back true if the given node is valid,262 /// i e. it is a real node of thegraph.234 /// This function gives back \c true if the given node is valid, 235 /// i.e. it is a real node of the digraph. 263 236 /// 264 237 /// \warning A removed node (using Snapshot) could become valid again 265 /// when new nodes are added to thegraph.238 /// if new nodes are added to the digraph. 266 239 bool valid(Node n) const { return Parent::valid(n); } 267 240 268 241 /// \brief Arc validity check 269 242 /// 270 /// This function gives back true if the given arc is valid,271 /// i e. it is a real arc of thegraph.243 /// This function gives back \c true if the given arc is valid, 244 /// i.e. it is a real arc of the digraph. 272 245 /// 273 246 /// \warning A removed arc (using Snapshot) could become valid again 274 /// whennew arcs are added to the graph.247 /// if new arcs are added to the graph. 275 248 bool valid(Arc a) const { return Parent::valid(a); } 276 249 277 ///Clear the digraph.278 279 ///Erase all the nodes and arcs from the digraph.280 ///281 void clear() {282 Parent::clear();283 }284 285 250 ///Split a node. 286 251 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. 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. 291 258 ///\return The newly created node. 292 259 /// 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. 260 ///\note All iterators remain valid. 261 /// 297 262 ///\warning This functionality cannot be used together with the Snapshot 298 263 ///feature. … … 309 274 } 310 275 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 memory 287 /// allocation: if you know that the digraph you want to build will 288 /// be large (e.g. it will contain millions of nodes and/or arcs), 289 /// then it is worth reserving space for this amount before starting 290 /// 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 memory 297 /// allocation: if you know that the digraph you want to build will 298 /// be large (e.g. it will contain millions of nodes and/or arcs), 299 /// then it is worth reserving space for this amount before starting 300 /// to build the digraph. 301 /// \sa reserveNode() 302 void reserveArc(int m) { arcs.reserve(m); }; 303 311 304 public: 312 305 … … 333 326 public: 334 327 335 ///Class to make a snapshot of the digraph and to rest rore toit later.336 337 ///Class to make a snapshot of the digraph and to rest rore toit later.328 ///Class to make a snapshot of the digraph and to restore it later. 329 330 ///Class to make a snapshot of the digraph and to restore it later. 338 331 /// 339 332 ///The newly added nodes and arcs can be removed using the 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. 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. 349 345 class Snapshot 350 346 { … … 358 354 359 355 ///Default constructor. 360 ///To actually make a snapshot you must call save(). 361 /// 356 ///You have to call save() to actually make a snapshot. 362 357 Snapshot() : _graph(0) {} 363 358 ///Constructor that immediately makes a snapshot 364 359 365 ///This constructor immediately makes a snapshot of the digraph.366 /// \param graph The digraph we make a snapshot of.367 Snapshot(SmartDigraph &gr aph) : _graph(&graph) {360 ///This constructor immediately makes a snapshot of the given digraph. 361 /// 362 Snapshot(SmartDigraph &gr) : _graph(&gr) { 368 363 node_num=_graph->nodes.size(); 369 364 arc_num=_graph->arcs.size(); … … 372 367 ///Make a snapshot. 373 368 374 ///Make a snapshot of the digraph. 375 /// 376 ///This function can be called more than once. In case of a repeated 369 ///This function makes a snapshot of the given digraph. 370 ///It can be called more than once. In case of a repeated 377 371 ///call, the previous snapshot gets lost. 378 ///\param graph The digraph we make the snapshot of. 379 void save(SmartDigraph &graph) 380 { 381 _graph=&graph; 372 void save(SmartDigraph &gr) { 373 _graph=&gr; 382 374 node_num=_graph->nodes.size(); 383 375 arc_num=_graph->arcs.size(); … … 386 378 ///Undo the changes until a snapshot. 387 379 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(). 380 ///This function undos the changes until the last snapshot 381 ///created by save() or Snapshot(SmartDigraph&). 393 382 void restore() 394 383 { … … 509 498 } 510 499 511 void next(Node& node) const{500 static void next(Node& node) { 512 501 --node._id; 513 502 } … … 517 506 } 518 507 519 void next(Arc& arc) const{508 static void next(Arc& arc) { 520 509 --arc._id; 521 510 } … … 525 514 } 526 515 527 void next(Edge& arc) const{516 static void next(Edge& arc) { 528 517 --arc._id; 529 518 } … … 622 611 /// \brief A smart undirected graph class. 623 612 /// 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". 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). 629 617 /// 630 /// \sa concepts::Graph. 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 631 625 class SmartGraph : public ExtendedSmartGraphBase { 632 626 typedef ExtendedSmartGraphBase Parent; 633 627 634 628 private: 635 636 ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. 637 638 ///SmartGraph is \e not copy constructible. Use GraphCopy() instead. 639 /// 629 /// Graphs are \e not copy constructible. Use GraphCopy instead. 640 630 SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {}; 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. 631 /// \brief Assignment of a graph to another one is \e not allowed. 632 /// Use GraphCopy instead. 647 633 void operator=(const SmartGraph &) {} 648 634 … … 655 641 SmartGraph() {} 656 642 657 /// Add a new node to the graph.658 659 /// Adda new node to the graph.643 /// \brief Add a new node to the graph. 644 /// 645 /// This function adds a new node to the graph. 660 646 /// \return The new node. 661 647 Node addNode() { return Parent::addNode(); } 662 648 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); 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); 670 657 } 671 658 672 659 /// \brief Node validity check 673 660 /// 674 /// This function gives back true if the given node is valid,675 /// i e. it is a real node of the graph.661 /// This function gives back \c true if the given node is valid, 662 /// i.e. it is a real node of the graph. 676 663 /// 677 664 /// \warning A removed node (using Snapshot) could become valid again 678 /// whennew nodes are added to the graph.665 /// if new nodes are added to the graph. 679 666 bool valid(Node n) const { return Parent::valid(n); } 680 667 668 /// \brief Edge validity check 669 /// 670 /// This function gives back \c true if the given edge is valid, 671 /// i.e. it is a real edge of the graph. 672 /// 673 /// \warning A removed edge (using Snapshot) could become valid again 674 /// if new edges are added to the graph. 675 bool valid(Edge e) const { return Parent::valid(e); } 676 681 677 /// \brief Arc validity check 682 678 /// 683 /// This function gives back true if the given arc is valid,684 /// i e. it is a real arc of the graph.679 /// This function gives back \c true if the given arc is valid, 680 /// i.e. it is a real arc of the graph. 685 681 /// 686 682 /// \warning A removed arc (using Snapshot) could become valid again 687 /// whennew edges are added to the graph.683 /// if new edges are added to the graph. 688 684 bool valid(Arc a) const { return Parent::valid(a); } 689 685 690 /// \brief Edge validity check691 ///692 /// This function gives back true if the given edge is valid,693 /// ie. it is a real edge of the graph.694 ///695 /// \warning A removed edge (using Snapshot) could become valid again696 /// when new edges are added to the graph.697 bool valid(Edge e) const { return Parent::valid(e); }698 699 686 ///Clear the graph. 700 687 701 /// Erase all the nodes and edges from the graph.688 ///This function erases all nodes and arcs from the graph. 702 689 /// 703 690 void clear() { 704 691 Parent::clear(); 705 692 } 693 694 /// Reserve memory for nodes. 695 696 /// Using this function, it is possible to avoid superfluous memory 697 /// allocation: if you know that the graph you want to build will 698 /// be large (e.g. it will contain millions of nodes and/or edges), 699 /// then it is worth reserving space for this amount before starting 700 /// 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 memory 707 /// allocation: if you know that the graph you want to build will 708 /// be large (e.g. it will contain millions of nodes and/or edges), 709 /// then it is worth reserving space for this amount before starting 710 /// to build the graph. 711 /// \sa reserveNode() 712 void reserveEdge(int m) { arcs.reserve(2 * m); }; 706 713 707 714 public: … … 743 750 public: 744 751 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. 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. 760 768 class Snapshot 761 769 { … … 769 777 770 778 ///Default constructor. 771 ///To actually make a snapshot you must call save(). 772 /// 779 ///You have to call save() to actually make a snapshot. 773 780 Snapshot() : _graph(0) {} 774 781 ///Constructor that immediately makes a snapshot 775 782 776 /// This constructor immediately makes a snapshot of the digraph.777 /// \param graph The digraph we make a snapshot of.778 Snapshot(SmartGraph &gr aph) {779 gr aph.saveSnapshot(*this);783 /// This constructor immediately makes a snapshot of the given graph. 784 /// 785 Snapshot(SmartGraph &gr) { 786 gr.saveSnapshot(*this); 780 787 } 781 788 782 789 ///Make a snapshot. 783 790 784 ///Make a snapshot of the graph. 785 /// 786 ///This function can be called more than once. In case of a repeated 791 ///This function makes a snapshot of the given graph. 792 ///It can be called more than once. In case of a repeated 787 793 ///call, the previous snapshot gets lost. 788 ///\param graph The digraph we make the snapshot of. 789 void save(SmartGraph &graph) 794 void save(SmartGraph &gr) 790 795 { 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(). 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&). 801 803 void restore() 802 804 { -
lemon/soplex.cc
r623 r793 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 94 107 95 108 void SoplexLp::_eraseCol(int i) { -
lemon/soplex.h
r623 r793 85 85 virtual int _addCol(); 86 86 virtual int _addRow(); 87 virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u); 87 88 88 89 virtual void _eraseCol(int i); -
m4/lx_check_coin.m4
r674 r796 89 89 CBC_LDFLAGS="-L$with_coin/lib" 90 90 fi 91 CBC_LIBS="-lOsi -lCbc -l OsiCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"91 CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas" 92 92 93 93 lx_save_cxxflags="$CXXFLAGS" -
scripts/chg-len.py
r439 r780 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-2009 6 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 7 # (Egervary Research Group on Combinatorial Optimization, EGRES). 8 # 9 # Permission to use, modify and distribute this software is granted 10 # provided that this copyright notice appears in all copies. For 11 # 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 any 15 # purpose. 2 16 3 17 import sys -
scripts/mk-release.sh
r611 r780 1 1 #!/bin/bash 2 # 3 # This file is a part of LEMON, a generic C++ optimization library. 4 # 5 # Copyright (C) 2003-2009 6 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 7 # (Egervary Research Group on Combinatorial Optimization, EGRES). 8 # 9 # Permission to use, modify and distribute this software is granted 10 # provided that this copyright notice appears in all copies. For 11 # 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 any 15 # purpose. 2 16 3 17 set -e -
scripts/unify-sources.sh
r702 r780 1 1 #!/bin/bash 2 # 3 # This file is a part of LEMON, a generic C++ optimization library. 4 # 5 # Copyright (C) 2003-2009 6 # Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 7 # (Egervary Research Group on Combinatorial Optimization, EGRES). 8 # 9 # Permission to use, modify and distribute this software is granted 10 # provided that this copyright notice appears in all copies. For 11 # 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 any 15 # purpose. 2 16 3 17 YEAR=`date +%Y` -
test/CMakeLists.txt
r745 r817 33 33 min_cost_arborescence_test 34 34 min_cost_flow_test 35 min_mean_cycle_test 35 36 path_test 36 37 preflow_test -
test/Makefile.am
r745 r817 31 31 test/min_cost_arborescence_test \ 32 32 test/min_cost_flow_test \ 33 test/min_mean_cycle_test \ 33 34 test/path_test \ 34 35 test/preflow_test \ … … 79 80 test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc 80 81 test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc 82 test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc 81 83 test_path_test_SOURCES = test/path_test.cc 82 84 test_preflow_test_SOURCES = test/preflow_test.cc -
test/adaptors_test.cc
r488 r550 1372 1372 1373 1373 GridGraph::EdgeMap<bool> dir_map(graph); 1374 dir_map[graph.right(n1)] = graph.u(graph.right(n1)) == n1;1375 dir_map[graph.up(n1)] = graph.u(graph.up(n1)) != n1;1376 dir_map[graph.left(n4)] = graph.u(graph.left(n4)) != n4;1377 dir_map[graph.down(n4)] = graph.u(graph.down(n4)) != n4;1374 dir_map[graph.right(n1)] = graph.u(graph.right(n1)) != n1; 1375 dir_map[graph.up(n1)] = graph.u(graph.up(n1)) == n1; 1376 dir_map[graph.left(n4)] = graph.u(graph.left(n4)) == n4; 1377 dir_map[graph.down(n4)] = graph.u(graph.down(n4)) == n4; 1378 1378 1379 1379 // Apply several adaptors on the grid graph 1380 typedef SplitNodes< ReverseDigraph< const Orienter< 1381 const GridGraph, GridGraph::EdgeMap<bool> > > > 1382 RevSplitGridGraph; 1383 typedef ReverseDigraph<const RevSplitGridGraph> SplitGridGraph; 1380 typedef SplitNodes<Orienter< const GridGraph, GridGraph::EdgeMap<bool> > > 1381 SplitGridGraph; 1384 1382 typedef Undirector<const SplitGridGraph> USplitGridGraph; 1385 typedef Undirector<const USplitGridGraph> UUSplitGridGraph;1386 checkConcept<concepts::Digraph, RevSplitGridGraph>();1387 1383 checkConcept<concepts::Digraph, SplitGridGraph>(); 1388 1384 checkConcept<concepts::Graph, USplitGridGraph>(); 1389 checkConcept<concepts::Graph, UUSplitGridGraph>(); 1390 1391 RevSplitGridGraph rev_adaptor = 1392 splitNodes(reverseDigraph(orienter(graph, dir_map))); 1393 SplitGridGraph adaptor = reverseDigraph(rev_adaptor); 1385 1386 SplitGridGraph adaptor = splitNodes(orienter(graph, dir_map)); 1394 1387 USplitGridGraph uadaptor = undirector(adaptor); 1395 UUSplitGridGraph uuadaptor = undirector(uadaptor);1396 1388 1397 1389 // Check adaptor … … 1400 1392 checkGraphConArcList(adaptor, 8); 1401 1393 1402 checkGraphOutArcList(adaptor, rev_adaptor.inNode(n1), 1);1403 checkGraphOutArcList(adaptor, rev_adaptor.outNode(n1), 1);1404 checkGraphOutArcList(adaptor, rev_adaptor.inNode(n2), 2);1405 checkGraphOutArcList(adaptor, rev_adaptor.outNode(n2), 1);1406 checkGraphOutArcList(adaptor, rev_adaptor.inNode(n3), 1);1407 checkGraphOutArcList(adaptor, rev_adaptor.outNode(n3), 1);1408 checkGraphOutArcList(adaptor, rev_adaptor.inNode(n4), 0);1409 checkGraphOutArcList(adaptor, rev_adaptor.outNode(n4), 1);1410 1411 checkGraphInArcList(adaptor, rev_adaptor.inNode(n1), 1);1412 checkGraphInArcList(adaptor, rev_adaptor.outNode(n1), 1);1413 checkGraphInArcList(adaptor, rev_adaptor.inNode(n2), 1);1414 checkGraphInArcList(adaptor, rev_adaptor.outNode(n2), 0);1415 checkGraphInArcList(adaptor, rev_adaptor.inNode(n3), 1);1416 checkGraphInArcList(adaptor, rev_adaptor.outNode(n3), 1);1417 checkGraphInArcList(adaptor, rev_adaptor.inNode(n4), 1);1418 checkGraphInArcList(adaptor, rev_adaptor.outNode(n4), 2);1394 checkGraphOutArcList(adaptor, adaptor.inNode(n1), 1); 1395 checkGraphOutArcList(adaptor, adaptor.outNode(n1), 1); 1396 checkGraphOutArcList(adaptor, adaptor.inNode(n2), 1); 1397 checkGraphOutArcList(adaptor, adaptor.outNode(n2), 0); 1398 checkGraphOutArcList(adaptor, adaptor.inNode(n3), 1); 1399 checkGraphOutArcList(adaptor, adaptor.outNode(n3), 1); 1400 checkGraphOutArcList(adaptor, adaptor.inNode(n4), 1); 1401 checkGraphOutArcList(adaptor, adaptor.outNode(n4), 2); 1402 1403 checkGraphInArcList(adaptor, adaptor.inNode(n1), 1); 1404 checkGraphInArcList(adaptor, adaptor.outNode(n1), 1); 1405 checkGraphInArcList(adaptor, adaptor.inNode(n2), 2); 1406 checkGraphInArcList(adaptor, adaptor.outNode(n2), 1); 1407 checkGraphInArcList(adaptor, adaptor.inNode(n3), 1); 1408 checkGraphInArcList(adaptor, adaptor.outNode(n3), 1); 1409 checkGraphInArcList(adaptor, adaptor.inNode(n4), 0); 1410 checkGraphInArcList(adaptor, adaptor.outNode(n4), 1); 1419 1411 1420 1412 checkNodeIds(adaptor); … … 1439 1431 checkGraphArcMap(uadaptor); 1440 1432 1441 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n1), 2); 1442 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n1), 2); 1443 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n2), 3); 1444 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n2), 1); 1445 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n3), 2); 1446 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n3), 2); 1447 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n4), 1); 1448 checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n4), 3); 1449 1450 // Check uuadaptor 1451 checkGraphNodeList(uuadaptor, 8); 1452 checkGraphEdgeList(uuadaptor, 16); 1453 checkGraphArcList(uuadaptor, 32); 1454 checkGraphConEdgeList(uuadaptor, 16); 1455 checkGraphConArcList(uuadaptor, 32); 1456 1457 checkNodeIds(uuadaptor); 1458 checkEdgeIds(uuadaptor); 1459 checkArcIds(uuadaptor); 1460 1461 checkGraphNodeMap(uuadaptor); 1462 checkGraphEdgeMap(uuadaptor); 1463 checkGraphArcMap(uuadaptor); 1433 checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n1), 2); 1434 checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n1), 2); 1435 checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n2), 3); 1436 checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n2), 1); 1437 checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n3), 2); 1438 checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n3), 2); 1439 checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n4), 1); 1440 checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n4), 3); 1464 1441 } 1465 1442 -
test/bellman_ford_test.cc
r837 r838 97 97 p = const_bf_test.predMap(); 98 98 pp = const_bf_test.path(t); 99 pp = const_bf_test.negativeCycle(); 99 100 100 101 for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {} … … 133 134 b = bf_test.reached(t); 134 135 pp = bf_test.path(t); 136 pp = bf_test.negativeCycle(); 135 137 } 136 138 } … … 221 223 } 222 224 225 void checkBellmanFordNegativeCycle() { 226 DIGRAPH_TYPEDEFS(SmartDigraph); 227 228 SmartDigraph gr; 229 IntArcMap length(gr); 230 231 Node n1 = gr.addNode(); 232 Node n2 = gr.addNode(); 233 Node n3 = gr.addNode(); 234 Node n4 = gr.addNode(); 235 236 Arc a1 = gr.addArc(n1, n2); 237 Arc a2 = gr.addArc(n2, n2); 238 239 length[a1] = 2; 240 length[a2] = -1; 241 242 { 243 BellmanFord<SmartDigraph, IntArcMap> bf(gr, length); 244 bf.run(n1); 245 StaticPath<SmartDigraph> p = bf.negativeCycle(); 246 check(p.length() == 1 && p.front() == p.back() && p.front() == a2, 247 "Wrong negative cycle."); 248 } 249 250 length[a2] = 0; 251 252 { 253 BellmanFord<SmartDigraph, IntArcMap> bf(gr, length); 254 bf.run(n1); 255 check(bf.negativeCycle().empty(), 256 "Negative cycle should not be found."); 257 } 258 259 length[gr.addArc(n1, n3)] = 5; 260 length[gr.addArc(n4, n3)] = 1; 261 length[gr.addArc(n2, n4)] = 2; 262 length[gr.addArc(n3, n2)] = -4; 263 264 { 265 BellmanFord<SmartDigraph, IntArcMap> bf(gr, length); 266 bf.init(); 267 bf.addSource(n1); 268 for (int i = 0; i < 4; ++i) { 269 check(bf.negativeCycle().empty(), 270 "Negative cycle should not be found."); 271 bf.processNextRound(); 272 } 273 StaticPath<SmartDigraph> p = bf.negativeCycle(); 274 check(p.length() == 3, "Wrong negative cycle."); 275 check(length[p.nth(0)] + length[p.nth(1)] + length[p.nth(2)] == -1, 276 "Wrong negative cycle."); 277 } 278 } 279 223 280 int main() { 224 281 checkBellmanFord<ListDigraph, int>(); 225 282 checkBellmanFord<SmartDigraph, double>(); 283 checkBellmanFordNegativeCycle(); 226 284 return 0; 227 285 } -
test/circulation_test.cc
r658 r736 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); 90 95 91 96 circ_test.init(); -
test/digraph_test.cc
r463 r827 20 20 #include <lemon/list_graph.h> 21 21 #include <lemon/smart_graph.h> 22 #include <lemon/static_graph.h> 22 23 #include <lemon/full_graph.h> 23 24 … … 35 36 checkGraphNodeList(G, 0); 36 37 checkGraphArcList(G, 0); 38 39 G.reserveNode(3); 40 G.reserveArc(4); 37 41 38 42 Node … … 284 288 285 289 snapshot.restore(); 290 snapshot.save(G); 291 292 checkGraphNodeList(G, 4); 293 checkGraphArcList(G, 4); 294 295 G.addArc(G.addNode(), G.addNode()); 296 297 snapshot.restore(); 286 298 287 299 checkGraphNodeList(G, 4); … … 318 330 checkConcept<ClearableDigraphComponent<>, SmartDigraph>(); 319 331 } 332 { // Checking StaticDigraph 333 checkConcept<Digraph, StaticDigraph>(); 334 checkConcept<ClearableDigraphComponent<>, StaticDigraph>(); 335 } 320 336 { // Checking FullDigraph 321 337 checkConcept<Digraph, FullDigraph>(); … … 373 389 } 374 390 391 void checkStaticDigraph() { 392 SmartDigraph g; 393 SmartDigraph::NodeMap<StaticDigraph::Node> nref(g); 394 SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g); 395 396 StaticDigraph G; 397 398 checkGraphNodeList(G, 0); 399 checkGraphArcList(G, 0); 400 401 G.build(g, nref, aref); 402 403 checkGraphNodeList(G, 0); 404 checkGraphArcList(G, 0); 405 406 SmartDigraph::Node 407 n1 = g.addNode(), 408 n2 = g.addNode(), 409 n3 = g.addNode(); 410 411 G.build(g, nref, aref); 412 413 checkGraphNodeList(G, 3); 414 checkGraphArcList(G, 0); 415 416 SmartDigraph::Arc a1 = g.addArc(n1, n2); 417 418 G.build(g, nref, aref); 419 420 check(G.source(aref[a1]) == nref[n1] && G.target(aref[a1]) == nref[n2], 421 "Wrong arc or wrong references"); 422 checkGraphNodeList(G, 3); 423 checkGraphArcList(G, 1); 424 425 checkGraphOutArcList(G, nref[n1], 1); 426 checkGraphOutArcList(G, nref[n2], 0); 427 checkGraphOutArcList(G, nref[n3], 0); 428 429 checkGraphInArcList(G, nref[n1], 0); 430 checkGraphInArcList(G, nref[n2], 1); 431 checkGraphInArcList(G, nref[n3], 0); 432 433 checkGraphConArcList(G, 1); 434 435 SmartDigraph::Arc 436 a2 = g.addArc(n2, n1), 437 a3 = g.addArc(n2, n3), 438 a4 = g.addArc(n2, n3); 439 440 digraphCopy(g, G).nodeRef(nref).run(); 441 442 checkGraphNodeList(G, 3); 443 checkGraphArcList(G, 4); 444 445 checkGraphOutArcList(G, nref[n1], 1); 446 checkGraphOutArcList(G, nref[n2], 3); 447 checkGraphOutArcList(G, nref[n3], 0); 448 449 checkGraphInArcList(G, nref[n1], 1); 450 checkGraphInArcList(G, nref[n2], 1); 451 checkGraphInArcList(G, nref[n3], 2); 452 453 checkGraphConArcList(G, 4); 454 455 std::vector<std::pair<int,int> > arcs; 456 arcs.push_back(std::make_pair(0,1)); 457 arcs.push_back(std::make_pair(0,2)); 458 arcs.push_back(std::make_pair(1,3)); 459 arcs.push_back(std::make_pair(1,2)); 460 arcs.push_back(std::make_pair(3,0)); 461 arcs.push_back(std::make_pair(3,3)); 462 arcs.push_back(std::make_pair(4,2)); 463 arcs.push_back(std::make_pair(4,3)); 464 arcs.push_back(std::make_pair(4,1)); 465 466 G.build(6, arcs.begin(), arcs.end()); 467 468 checkGraphNodeList(G, 6); 469 checkGraphArcList(G, 9); 470 471 checkGraphOutArcList(G, G.node(0), 2); 472 checkGraphOutArcList(G, G.node(1), 2); 473 checkGraphOutArcList(G, G.node(2), 0); 474 checkGraphOutArcList(G, G.node(3), 2); 475 checkGraphOutArcList(G, G.node(4), 3); 476 checkGraphOutArcList(G, G.node(5), 0); 477 478 checkGraphInArcList(G, G.node(0), 1); 479 checkGraphInArcList(G, G.node(1), 2); 480 checkGraphInArcList(G, G.node(2), 3); 481 checkGraphInArcList(G, G.node(3), 3); 482 checkGraphInArcList(G, G.node(4), 0); 483 checkGraphInArcList(G, G.node(5), 0); 484 485 checkGraphConArcList(G, 9); 486 487 checkNodeIds(G); 488 checkArcIds(G); 489 checkGraphNodeMap(G); 490 checkGraphArcMap(G); 491 492 int n = G.nodeNum(); 493 int m = G.arcNum(); 494 check(G.index(G.node(n-1)) == n-1, "Wrong index."); 495 check(G.index(G.arc(m-1)) == m-1, "Wrong index."); 496 } 497 375 498 void checkFullDigraph(int num) { 376 499 typedef FullDigraph Digraph; 377 500 DIGRAPH_TYPEDEFS(Digraph); 501 378 502 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"); 379 507 380 508 checkGraphNodeList(G, num); … … 420 548 checkDigraphValidity<SmartDigraph>(); 421 549 } 550 { // Checking StaticDigraph 551 checkStaticDigraph(); 552 } 422 553 { // Checking FullDigraph 423 554 checkFullDigraph(8); -
test/graph_test.cc
r463 r787 39 39 checkGraphArcList(G, 0); 40 40 41 G.reserveNode(3); 42 G.reserveEdge(3); 43 41 44 Node 42 45 n1 = G.addNode(), … … 257 260 258 261 snapshot.restore(); 262 snapshot.save(G); 263 264 checkGraphNodeList(G, 4); 265 checkGraphEdgeList(G, 3); 266 checkGraphArcList(G, 6); 267 268 G.addEdge(G.addNode(), G.addNode()); 269 270 snapshot.restore(); 259 271 260 272 checkGraphNodeList(G, 4); … … 268 280 269 281 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 270 289 checkGraphNodeList(G, num); 271 290 checkGraphEdgeList(G, num * (num - 1) / 2); … … 412 431 check(G.height() == height, "Wrong row number"); 413 432 433 G.resize(width, height); 434 check(G.width() == width, "Wrong column number"); 435 check(G.height() == height, "Wrong row number"); 436 414 437 for (int i = 0; i < width; ++i) { 415 438 for (int j = 0; j < height; ++j) { … … 487 510 488 511 HypercubeGraph G(dim); 512 check(G.dimension() == dim, "Wrong dimension"); 513 514 G.resize(dim); 515 check(G.dimension() == dim, "Wrong dimension"); 516 489 517 checkGraphNodeList(G, 1 << dim); 490 518 checkGraphEdgeList(G, dim * (1 << (dim-1))); -
test/heap_test.cc
r728 r749 26 26 27 27 #include <lemon/smart_graph.h> 28 29 28 #include <lemon/lgf_reader.h> 30 29 #include <lemon/dijkstra.h> … … 32 31 33 32 #include <lemon/bin_heap.h> 33 #include <lemon/fourary_heap.h> 34 #include <lemon/kary_heap.h> 34 35 #include <lemon/fib_heap.h> 36 #include <lemon/pairing_heap.h> 35 37 #include <lemon/radix_heap.h> 38 #include <lemon/binom_heap.h> 36 39 #include <lemon/bucket_heap.h> 37 40 … … 90 93 void heapSortTest() { 91 94 RangeMap<int> map(test_len, -1); 92 93 95 Heap heap(map); 94 96 95 97 std::vector<int> v(test_len); 96 97 98 for (int i = 0; i < test_len; ++i) { 98 99 v[i] = test_seq[i]; … … 101 102 std::sort(v.begin(), v.end()); 102 103 for (int i = 0; i < test_len; ++i) { 103 check(v[i] == heap.prio() ,"Wrong order in heap sort.");104 check(v[i] == heap.prio(), "Wrong order in heap sort."); 104 105 heap.pop(); 105 106 } … … 113 114 114 115 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 132 130 133 131 template <typename Heap> … … 145 143 if (dijkstra.reached(s)) { 146 144 check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a], 147 "Error in a shortest path tree!");145 "Error in shortest path tree."); 148 146 } 149 147 } … … 154 152 Node s = digraph.source(a); 155 153 check( dijkstra.dist(n) - dijkstra.dist(s) == length[a], 156 "Error in a shortest path tree!");154 "Error in shortest path tree."); 157 155 } 158 156 } … … 176 174 run(); 177 175 176 // BinHeap 178 177 { 179 178 typedef BinHeap<Prio, ItemIntMap> IntHeap; … … 187 186 } 188 187 188 // FouraryHeap 189 { 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 // KaryHeap 201 { 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 // FibHeap 189 213 { 190 214 typedef FibHeap<Prio, ItemIntMap> IntHeap; … … 198 222 } 199 223 224 // PairingHeap 225 { 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 // RadixHeap 200 237 { 201 238 typedef RadixHeap<ItemIntMap> IntHeap; … … 209 246 } 210 247 248 // BinomHeap 249 { 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, SimpleBucketHeap 211 261 { 212 262 typedef BucketHeap<ItemIntMap> IntHeap; … … 218 268 checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>(); 219 269 dijkstraHeapTest<NodeHeap>(digraph, length, source); 220 } 221 270 271 typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap; 272 heapSortTest<SimpleIntHeap>(); 273 } 222 274 223 275 return 0; -
test/maps_test.cc
r554 r836 23 23 #include <lemon/concepts/maps.h> 24 24 #include <lemon/maps.h> 25 #include <lemon/list_graph.h> 26 #include <lemon/smart_graph.h> 27 #include <lemon/adaptors.h> 28 #include <lemon/dfs.h> 29 #include <algorithm> 25 30 26 31 #include "test_tools.h" … … 34 39 35 40 class C { 36 int x;41 int _x; 37 42 public: 38 C(int _x) : x(_x) {} 43 C(int x) : _x(x) {} 44 int get() const { return _x; } 45 }; 46 inline bool operator<(C c1, C c2) { return c1.get() < c2.get(); } 47 inline bool operator==(C c1, C c2) { return c1.get() == c2.get(); } 48 49 C createC(int x) { return C(x); } 50 51 template <typename T> 52 class Less { 53 T _t; 54 public: 55 Less(T t): _t(t) {} 56 bool operator()(const T& t) const { return t < _t; } 39 57 }; 40 58 … … 52 70 53 71 int binc(int a, B) { return a+1; } 72 73 template <typename T> 74 class Sum { 75 T& _sum; 76 public: 77 Sum(T& sum) : _sum(sum) {} 78 void operator()(const T& t) { _sum += t; } 79 }; 54 80 55 81 typedef ReadMap<A, double> DoubleMap; … … 329 355 { 330 356 typedef std::vector<int> vec; 357 checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >(); 358 checkConcept<WriteMap<int, bool>, 359 LoggerBoolMap<std::back_insert_iterator<vec> > >(); 360 331 361 vec v1; 332 362 vec v2(10); … … 348 378 it != map2.end(); ++it ) 349 379 check(v1[i++] == *it, "Something is wrong with LoggerBoolMap"); 350 } 351 380 381 typedef ListDigraph Graph; 382 DIGRAPH_TYPEDEFS(Graph); 383 Graph gr; 384 385 Node n0 = gr.addNode(); 386 Node n1 = gr.addNode(); 387 Node n2 = gr.addNode(); 388 Node n3 = gr.addNode(); 389 390 gr.addArc(n3, n0); 391 gr.addArc(n3, n2); 392 gr.addArc(n0, n2); 393 gr.addArc(n2, n1); 394 gr.addArc(n0, n1); 395 396 { 397 std::vector<Node> v; 398 dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run(); 399 400 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3, 401 "Something is wrong with LoggerBoolMap"); 402 } 403 { 404 std::vector<Node> v(countNodes(gr)); 405 dfs(gr).processedMap(loggerBoolMap(v.begin())).run(); 406 407 check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3, 408 "Something is wrong with LoggerBoolMap"); 409 } 410 } 411 412 // IdMap, RangeIdMap 413 { 414 typedef ListDigraph Graph; 415 DIGRAPH_TYPEDEFS(Graph); 416 417 checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >(); 418 checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >(); 419 checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >(); 420 checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >(); 421 422 Graph gr; 423 IdMap<Graph, Node> nmap(gr); 424 IdMap<Graph, Arc> amap(gr); 425 RangeIdMap<Graph, Node> nrmap(gr); 426 RangeIdMap<Graph, Arc> armap(gr); 427 428 Node n0 = gr.addNode(); 429 Node n1 = gr.addNode(); 430 Node n2 = gr.addNode(); 431 432 Arc a0 = gr.addArc(n0, n1); 433 Arc a1 = gr.addArc(n0, n2); 434 Arc a2 = gr.addArc(n2, n1); 435 Arc a3 = gr.addArc(n2, n0); 436 437 check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap"); 438 check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap"); 439 check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap"); 440 441 check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap"); 442 check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap"); 443 check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap"); 444 check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap"); 445 446 check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap"); 447 check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap"); 448 449 check(nrmap.size() == 3 && armap.size() == 4, 450 "Wrong RangeIdMap::size()"); 451 452 check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap"); 453 check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap"); 454 check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap"); 455 456 check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap"); 457 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap"); 458 check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap"); 459 check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap"); 460 461 check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap"); 462 check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap"); 463 464 gr.erase(n1); 465 466 if (nrmap[n0] == 1) nrmap.swap(n0, n2); 467 nrmap.swap(n2, n0); 468 if (armap[a1] == 1) armap.swap(a1, a3); 469 armap.swap(a3, a1); 470 471 check(nrmap.size() == 2 && armap.size() == 2, 472 "Wrong RangeIdMap::size()"); 473 474 check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap"); 475 check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap"); 476 477 check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap"); 478 check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap"); 479 480 check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap"); 481 check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap"); 482 } 483 484 // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap 485 { 486 typedef ListGraph Graph; 487 GRAPH_TYPEDEFS(Graph); 488 489 checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >(); 490 checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >(); 491 checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >(); 492 checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >(); 493 checkConcept<ReadMap<Node, int>, InDegMap<Graph> >(); 494 checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >(); 495 496 Graph gr; 497 Node n0 = gr.addNode(); 498 Node n1 = gr.addNode(); 499 Node n2 = gr.addNode(); 500 501 gr.addEdge(n0,n1); 502 gr.addEdge(n1,n2); 503 gr.addEdge(n0,n2); 504 gr.addEdge(n2,n1); 505 gr.addEdge(n1,n2); 506 gr.addEdge(n0,n1); 507 508 for (EdgeIt e(gr); e != INVALID; ++e) { 509 check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap"); 510 check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap"); 511 } 512 513 check(mapCompare(gr, 514 sourceMap(orienter(gr, constMap<Edge, bool>(true))), 515 targetMap(orienter(gr, constMap<Edge, bool>(false)))), 516 "Wrong SourceMap or TargetMap"); 517 518 typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph; 519 Digraph dgr(gr, constMap<Edge, bool>(true)); 520 OutDegMap<Digraph> odm(dgr); 521 InDegMap<Digraph> idm(dgr); 522 523 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap"); 524 check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap"); 525 526 gr.addEdge(n2, n0); 527 528 check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap"); 529 check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap"); 530 } 531 532 // CrossRefMap 533 { 534 typedef ListDigraph Graph; 535 DIGRAPH_TYPEDEFS(Graph); 536 537 checkConcept<ReadWriteMap<Node, int>, 538 CrossRefMap<Graph, Node, int> >(); 539 checkConcept<ReadWriteMap<Node, bool>, 540 CrossRefMap<Graph, Node, bool> >(); 541 checkConcept<ReadWriteMap<Node, double>, 542 CrossRefMap<Graph, Node, double> >(); 543 544 Graph gr; 545 typedef CrossRefMap<Graph, Node, char> CRMap; 546 CRMap map(gr); 547 548 Node n0 = gr.addNode(); 549 Node n1 = gr.addNode(); 550 Node n2 = gr.addNode(); 551 552 map.set(n0, 'A'); 553 map.set(n1, 'B'); 554 map.set(n2, 'C'); 555 556 check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0, 557 "Wrong CrossRefMap"); 558 check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1, 559 "Wrong CrossRefMap"); 560 check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2, 561 "Wrong CrossRefMap"); 562 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, 563 "Wrong CrossRefMap::count()"); 564 565 CRMap::ValueIt it = map.beginValue(); 566 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && 567 it == map.endValue(), "Wrong value iterator"); 568 569 map.set(n2, 'A'); 570 571 check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A', 572 "Wrong CrossRefMap"); 573 check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap"); 574 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); 575 check(map('C') == INVALID && map.inverse()['C'] == INVALID, 576 "Wrong CrossRefMap"); 577 check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0, 578 "Wrong CrossRefMap::count()"); 579 580 it = map.beginValue(); 581 check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' && 582 it == map.endValue(), "Wrong value iterator"); 583 584 map.set(n0, 'C'); 585 586 check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A', 587 "Wrong CrossRefMap"); 588 check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap"); 589 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); 590 check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap"); 591 check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1, 592 "Wrong CrossRefMap::count()"); 593 594 it = map.beginValue(); 595 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && 596 it == map.endValue(), "Wrong value iterator"); 597 } 598 599 // CrossRefMap 600 { 601 typedef SmartDigraph Graph; 602 DIGRAPH_TYPEDEFS(Graph); 603 604 checkConcept<ReadWriteMap<Node, int>, 605 CrossRefMap<Graph, Node, int> >(); 606 607 Graph gr; 608 typedef CrossRefMap<Graph, Node, char> CRMap; 609 typedef CRMap::ValueIterator ValueIt; 610 CRMap map(gr); 611 612 Node n0 = gr.addNode(); 613 Node n1 = gr.addNode(); 614 Node n2 = gr.addNode(); 615 616 map.set(n0, 'A'); 617 map.set(n1, 'B'); 618 map.set(n2, 'C'); 619 map.set(n2, 'A'); 620 map.set(n0, 'C'); 621 622 check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A', 623 "Wrong CrossRefMap"); 624 check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap"); 625 check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap"); 626 check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap"); 627 628 ValueIt it = map.beginValue(); 629 check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' && 630 it == map.endValue(), "Wrong value iterator"); 631 } 632 633 // Iterable bool map 634 { 635 typedef SmartGraph Graph; 636 typedef SmartGraph::Node Item; 637 638 typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm; 639 checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>(); 640 641 const int num = 10; 642 Graph g; 643 std::vector<Item> items; 644 for (int i = 0; i < num; ++i) { 645 items.push_back(g.addNode()); 646 } 647 648 Ibm map1(g, true); 649 int n = 0; 650 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 651 check(map1[static_cast<Item>(it)], "Wrong TrueIt"); 652 ++n; 653 } 654 check(n == num, "Wrong number"); 655 656 n = 0; 657 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 658 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 659 ++n; 660 } 661 check(n == num, "Wrong number"); 662 check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt"); 663 check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false"); 664 665 map1[items[5]] = true; 666 667 n = 0; 668 for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) { 669 check(map1[static_cast<Item>(it)], "Wrong ItemIt for true"); 670 ++n; 671 } 672 check(n == num, "Wrong number"); 673 674 map1[items[num / 2]] = false; 675 check(map1[items[num / 2]] == false, "Wrong map value"); 676 677 n = 0; 678 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 679 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 680 ++n; 681 } 682 check(n == num - 1, "Wrong number"); 683 684 n = 0; 685 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 686 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 687 ++n; 688 } 689 check(n == 1, "Wrong number"); 690 691 map1[items[0]] = false; 692 check(map1[items[0]] == false, "Wrong map value"); 693 694 map1[items[num - 1]] = false; 695 check(map1[items[num - 1]] == false, "Wrong map value"); 696 697 n = 0; 698 for (Ibm::TrueIt it(map1); it != INVALID; ++it) { 699 check(map1[static_cast<Item>(it)], "Wrong TrueIt for true"); 700 ++n; 701 } 702 check(n == num - 3, "Wrong number"); 703 check(map1.trueNum() == num - 3, "Wrong number"); 704 705 n = 0; 706 for (Ibm::FalseIt it(map1); it != INVALID; ++it) { 707 check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true"); 708 ++n; 709 } 710 check(n == 3, "Wrong number"); 711 check(map1.falseNum() == 3, "Wrong number"); 712 } 713 714 // Iterable int map 715 { 716 typedef SmartGraph Graph; 717 typedef SmartGraph::Node Item; 718 typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim; 719 720 checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>(); 721 722 const int num = 10; 723 Graph g; 724 std::vector<Item> items; 725 for (int i = 0; i < num; ++i) { 726 items.push_back(g.addNode()); 727 } 728 729 Iim map1(g); 730 check(map1.size() == 0, "Wrong size"); 731 732 for (int i = 0; i < num; ++i) { 733 map1[items[i]] = i; 734 } 735 check(map1.size() == num, "Wrong size"); 736 737 for (int i = 0; i < num; ++i) { 738 Iim::ItemIt it(map1, i); 739 check(static_cast<Item>(it) == items[i], "Wrong value"); 740 ++it; 741 check(static_cast<Item>(it) == INVALID, "Wrong value"); 742 } 743 744 for (int i = 0; i < num; ++i) { 745 map1[items[i]] = i % 2; 746 } 747 check(map1.size() == 2, "Wrong size"); 748 749 int n = 0; 750 for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) { 751 check(map1[static_cast<Item>(it)] == 0, "Wrong value"); 752 ++n; 753 } 754 check(n == (num + 1) / 2, "Wrong number"); 755 756 for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) { 757 check(map1[static_cast<Item>(it)] == 1, "Wrong value"); 758 ++n; 759 } 760 check(n == num, "Wrong number"); 761 762 } 763 764 // Iterable value map 765 { 766 typedef SmartGraph Graph; 767 typedef SmartGraph::Node Item; 768 typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm; 769 770 checkConcept<ReadWriteMap<Item, double>, Ivm>(); 771 772 const int num = 10; 773 Graph g; 774 std::vector<Item> items; 775 for (int i = 0; i < num; ++i) { 776 items.push_back(g.addNode()); 777 } 778 779 Ivm map1(g, 0.0); 780 check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size"); 781 check(*map1.beginValue() == 0.0, "Wrong value"); 782 783 for (int i = 0; i < num; ++i) { 784 map1.set(items[i], static_cast<double>(i)); 785 } 786 check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size"); 787 788 for (int i = 0; i < num; ++i) { 789 Ivm::ItemIt it(map1, static_cast<double>(i)); 790 check(static_cast<Item>(it) == items[i], "Wrong value"); 791 ++it; 792 check(static_cast<Item>(it) == INVALID, "Wrong value"); 793 } 794 795 for (Ivm::ValueIt vit = map1.beginValue(); 796 vit != map1.endValue(); ++vit) { 797 check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit, 798 "Wrong ValueIt"); 799 } 800 801 for (int i = 0; i < num; ++i) { 802 map1.set(items[i], static_cast<double>(i % 2)); 803 } 804 check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size"); 805 806 int n = 0; 807 for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) { 808 check(map1[static_cast<Item>(it)] == 0.0, "Wrong value"); 809 ++n; 810 } 811 check(n == (num + 1) / 2, "Wrong number"); 812 813 for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) { 814 check(map1[static_cast<Item>(it)] == 1.0, "Wrong value"); 815 ++n; 816 } 817 check(n == num, "Wrong number"); 818 819 } 820 821 // Graph map utilities: 822 // mapMin(), mapMax(), mapMinValue(), mapMaxValue() 823 // mapFind(), mapFindIf(), mapCount(), mapCountIf() 824 // mapCopy(), mapCompare(), mapFill() 825 { 826 DIGRAPH_TYPEDEFS(SmartDigraph); 827 828 SmartDigraph g; 829 Node n1 = g.addNode(); 830 Node n2 = g.addNode(); 831 Node n3 = g.addNode(); 832 833 SmartDigraph::NodeMap<int> map1(g); 834 SmartDigraph::ArcMap<char> map2(g); 835 ConstMap<Node, A> cmap1 = A(); 836 ConstMap<Arc, C> cmap2 = C(0); 837 838 map1[n1] = 10; 839 map1[n2] = 5; 840 map1[n3] = 12; 841 842 // mapMin(), mapMax(), mapMinValue(), mapMaxValue() 843 check(mapMin(g, map1) == n2, "Wrong mapMin()"); 844 check(mapMax(g, map1) == n3, "Wrong mapMax()"); 845 check(mapMin(g, map1, std::greater<int>()) == n3, "Wrong mapMin()"); 846 check(mapMax(g, map1, std::greater<int>()) == n2, "Wrong mapMax()"); 847 check(mapMinValue(g, map1) == 5, "Wrong mapMinValue()"); 848 check(mapMaxValue(g, map1) == 12, "Wrong mapMaxValue()"); 849 850 check(mapMin(g, map2) == INVALID, "Wrong mapMin()"); 851 check(mapMax(g, map2) == INVALID, "Wrong mapMax()"); 852 853 check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()"); 854 check(mapMax(g, cmap2) == INVALID, "Wrong mapMax()"); 855 856 Arc a1 = g.addArc(n1, n2); 857 Arc a2 = g.addArc(n1, n3); 858 Arc a3 = g.addArc(n2, n3); 859 Arc a4 = g.addArc(n3, n1); 860 861 map2[a1] = 'b'; 862 map2[a2] = 'a'; 863 map2[a3] = 'b'; 864 map2[a4] = 'c'; 865 866 // mapMin(), mapMax(), mapMinValue(), mapMaxValue() 867 check(mapMin(g, map2) == a2, "Wrong mapMin()"); 868 check(mapMax(g, map2) == a4, "Wrong mapMax()"); 869 check(mapMin(g, map2, std::greater<int>()) == a4, "Wrong mapMin()"); 870 check(mapMax(g, map2, std::greater<int>()) == a2, "Wrong mapMax()"); 871 check(mapMinValue(g, map2, std::greater<int>()) == 'c', 872 "Wrong mapMinValue()"); 873 check(mapMaxValue(g, map2, std::greater<int>()) == 'a', 874 "Wrong mapMaxValue()"); 875 876 check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()"); 877 check(mapMax(g, cmap2) != INVALID, "Wrong mapMax()"); 878 check(mapMaxValue(g, cmap2) == C(0), "Wrong mapMaxValue()"); 879 880 check(mapMin(g, composeMap(functorToMap(&createC), map2)) == a2, 881 "Wrong mapMin()"); 882 check(mapMax(g, composeMap(functorToMap(&createC), map2)) == a4, 883 "Wrong mapMax()"); 884 check(mapMinValue(g, composeMap(functorToMap(&createC), map2)) == C('a'), 885 "Wrong mapMinValue()"); 886 check(mapMaxValue(g, composeMap(functorToMap(&createC), map2)) == C('c'), 887 "Wrong mapMaxValue()"); 888 889 // mapFind(), mapFindIf() 890 check(mapFind(g, map1, 5) == n2, "Wrong mapFind()"); 891 check(mapFind(g, map1, 6) == INVALID, "Wrong mapFind()"); 892 check(mapFind(g, map2, 'a') == a2, "Wrong mapFind()"); 893 check(mapFind(g, map2, 'e') == INVALID, "Wrong mapFind()"); 894 check(mapFind(g, cmap2, C(0)) == ArcIt(g), "Wrong mapFind()"); 895 check(mapFind(g, cmap2, C(1)) == INVALID, "Wrong mapFind()"); 896 897 check(mapFindIf(g, map1, Less<int>(7)) == n2, 898 "Wrong mapFindIf()"); 899 check(mapFindIf(g, map1, Less<int>(5)) == INVALID, 900 "Wrong mapFindIf()"); 901 check(mapFindIf(g, map2, Less<char>('d')) == ArcIt(g), 902 "Wrong mapFindIf()"); 903 check(mapFindIf(g, map2, Less<char>('a')) == INVALID, 904 "Wrong mapFindIf()"); 905 906 // mapCount(), mapCountIf() 907 check(mapCount(g, map1, 5) == 1, "Wrong mapCount()"); 908 check(mapCount(g, map1, 6) == 0, "Wrong mapCount()"); 909 check(mapCount(g, map2, 'a') == 1, "Wrong mapCount()"); 910 check(mapCount(g, map2, 'b') == 2, "Wrong mapCount()"); 911 check(mapCount(g, map2, 'e') == 0, "Wrong mapCount()"); 912 check(mapCount(g, cmap2, C(0)) == 4, "Wrong mapCount()"); 913 check(mapCount(g, cmap2, C(1)) == 0, "Wrong mapCount()"); 914 915 check(mapCountIf(g, map1, Less<int>(11)) == 2, 916 "Wrong mapCountIf()"); 917 check(mapCountIf(g, map1, Less<int>(13)) == 3, 918 "Wrong mapCountIf()"); 919 check(mapCountIf(g, map1, Less<int>(5)) == 0, 920 "Wrong mapCountIf()"); 921 check(mapCountIf(g, map2, Less<char>('d')) == 4, 922 "Wrong mapCountIf()"); 923 check(mapCountIf(g, map2, Less<char>('c')) == 3, 924 "Wrong mapCountIf()"); 925 check(mapCountIf(g, map2, Less<char>('a')) == 0, 926 "Wrong mapCountIf()"); 927 928 // MapIt, ConstMapIt 929 /* 930 These tests can be used after applying bugfix #330 931 typedef SmartDigraph::NodeMap<int>::MapIt MapIt; 932 typedef SmartDigraph::NodeMap<int>::ConstMapIt ConstMapIt; 933 check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5, 934 "Wrong NodeMap<>::MapIt"); 935 check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12, 936 "Wrong NodeMap<>::MapIt"); 937 938 int sum = 0; 939 std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum)); 940 check(sum == 27, "Wrong NodeMap<>::MapIt"); 941 std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum<int>(sum)); 942 check(sum == 54, "Wrong NodeMap<>::ConstMapIt"); 943 */ 944 945 // mapCopy(), mapCompare(), mapFill() 946 check(mapCompare(g, map1, map1), "Wrong mapCompare()"); 947 check(mapCompare(g, cmap2, cmap2), "Wrong mapCompare()"); 948 check(mapCompare(g, map1, shiftMap(map1, 0)), "Wrong mapCompare()"); 949 check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()"); 950 check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()"); 951 952 SmartDigraph::NodeMap<int> map3(g, 0); 953 SmartDigraph::ArcMap<char> map4(g, 'a'); 954 955 check(!mapCompare(g, map1, map3), "Wrong mapCompare()"); 956 check(!mapCompare(g, map2, map4), "Wrong mapCompare()"); 957 958 mapCopy(g, map1, map3); 959 mapCopy(g, map2, map4); 960 961 check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()"); 962 check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()"); 963 964 Undirector<SmartDigraph> ug(g); 965 Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x'); 966 Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14); 967 968 check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()"); 969 check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()"); 970 check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()"); 971 check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()"); 972 973 mapCopy(g, map2, umap1); 974 975 check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()"); 976 check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()"); 977 check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()"); 978 check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()"); 979 980 mapCopy(g, map2, umap1); 981 mapCopy(g, umap1, map2); 982 mapCopy(ug, map2, umap1); 983 mapCopy(ug, umap1, map2); 984 985 check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()"); 986 mapCopy(ug, umap1, umap2); 987 check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()"); 988 989 check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()"); 990 mapFill(g, map1, 2); 991 check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()"); 992 993 check(!mapCompare(g, map2, constMap<Arc>('z')), "Wrong mapCompare()"); 994 mapCopy(g, constMap<Arc>('z'), map2); 995 check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()"); 996 } 997 352 998 return 0; 353 999 } -
test/mip_test.cc
r678 r795 51 51 if (stat == MipSolver::OPTIMAL) { 52 52 std::ostringstream sbuf; 53 buf << "Wrong optimal value: the right optimum is " << exp_opt; 53 sbuf << "Wrong optimal value ("<< mip.solValue() 54 <<" instead of " << exp_opt << ")"; 54 55 check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str()); 55 56 //+ecvt(exp_opt,2) -
test/preflow_test.cc
r632 r736 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); 97 102 98 103 preflow_test -
test/test_tools.h
r463 r810 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 if(!(rc)) { \ 42 std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \ 43 abort(); \ 44 } else { } \ 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 45 49 46 50 #endif -
tools/lemon-0.x-to-1.x.sh
r621 r738 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"\ 71 76 -e "s/DigraphToEps/GraphToEps/g"\ 72 77 -e "s/digraphToEps/graphToEps/g"\
Note: See TracChangeset
for help on using the changeset viewer.