COIN-OR::LEMON - Graph Library

Ignore:
Files:
20 added
3 deleted
80 edited

Legend:

Unmodified
Added
Removed
  • .hgignore

    r610 r944  
    2323lemon/stamp-h2
    2424doc/Doxyfile
     25doc/references.dox
    2526cmake/version.cmake
    2627.dirstamp
  • CMakeLists.txt

    r727 r791  
    3535CHECK_TYPE_SIZE("long long" LONG_LONG)
    3636SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
     37
     38INCLUDE(FindPythonInterp)
    3739
    3840ENABLE_TESTING()
  • INSTALL

    r615 r890  
    174174
    175175   Disable COIN-OR support.
     176
     177
     178Makefile Variables
     179==================
     180
     181Some Makefile variables are reserved by the GNU Coding Standards for
     182the use of the "user" - the person building the package. For instance,
     183CXX and CXXFLAGS are such variables, and have the same meaning as
     184explained in the previous section. These variables can be set on the
     185command line when invoking `make' like this:
     186`make [VARIABLE=VALUE]...'
     187
     188WARNINGCXXFLAGS is a non-standard Makefile variable introduced by us
     189to hold several compiler flags related to warnings. Its default value
     190can be overridden when invoking `make'. For example to disable all
     191warning flags use `make WARNINGCXXFLAGS='.
     192
     193In order to turn off a single flag from the default set of warning
     194flags, you can use the CXXFLAGS variable, since this is passed after
     195WARNINGCXXFLAGS. For example to turn off `-Wold-style-cast' (which is
     196used by default when g++ is detected) you can use
     197`make CXXFLAGS="-g -O2 -Wno-old-style-cast"'.
  • Makefile.am

    r676 r840  
    1818        cmake/FindGLPK.cmake \
    1919        cmake/FindCOIN.cmake \
     20        cmake/LEMONConfig.cmake.in \
    2021        cmake/version.cmake.in \
    2122        cmake/version.cmake \
     
    4445include doc/Makefile.am
    4546include tools/Makefile.am
     47include scripts/Makefile.am
    4648
    4749DIST_SUBDIRS = demo
  • README

    r705 r921  
    1818   Copying, distribution and modification conditions and terms.
    1919
     20NEWS
     21
     22   News and version history.
     23
    2024INSTALL
    2125
     
    3438   Some example programs to make you easier to get familiar with LEMON.
    3539
     40scripts/
     41
     42   Scripts that make it easier to develop LEMON.
     43
    3644test/
    3745
  • configure.ac

    r727 r840  
    4242
    4343AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
     44AC_CHECK_PROG([python_found],[python],[yes],[no])
    4445AC_CHECK_PROG([gs_found],[gs],[yes],[no])
    4546
     
    8283fi
    8384AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
     85
     86dnl Support for running test cases using valgrind.
     87use_valgrind=no
     88AC_ARG_ENABLE([valgrind],
     89AS_HELP_STRING([--enable-valgrind], [use valgrind when running tests]),
     90              [use_valgrind=yes])
     91
     92if [[ "$use_valgrind" = "yes" ]]; then
     93  AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no)
     94
     95  if [[ "$HAVE_VALGRIND" = "no" ]]; then
     96    AC_MSG_ERROR([Valgrind not found in PATH.])
     97  fi
     98fi
     99AM_CONDITIONAL(USE_VALGRIND, [test "$use_valgrind" = "yes"])
    84100
    85101dnl Checks for header files.
     
    128144echo
    129145echo Build additional tools........ : $enable_tools
     146echo Use valgrind for tests........ : $use_valgrind
    130147echo
    131148echo The packace will be installed in
  • demo/arg_parser_demo.cc

    r463 r915  
    6666    .other("...");
    6767
     68  // Throw an exception when problems occurs. The default behavior is to
     69  // exit(1) on these cases, but this makes Valgrind falsely warn
     70  // about memory leaks.
     71  ap.throwOnProblems();
     72 
    6873  // Perform the parsing process
    6974  // (in case of any error it terminates the program)
    70   ap.parse();
     75  // The try {} construct is necessary only if the ap.trowOnProblems()
     76  // setting is in use.
     77  try {
     78    ap.parse();
     79  } catch (ArgParserException &) { return 1; }
    7180
    7281  // Check each option if it has been given and print its value
  • doc/CMakeLists.txt

    r726 r943  
    1010)
    1111
    12 IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
     12IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
    1313  FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
    1414  SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha)
     
    2121    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps
    2222    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps
     23    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/matching.eps
    2324    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps
    2425    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
     
    2728    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
    2829    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
     30    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/planar.png ${CMAKE_CURRENT_SOURCE_DIR}/images/planar.eps
    2931    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
    3032    COMMAND ${CMAKE_COMMAND} -E remove_directory html
     33    COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
    3134    COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
    3235    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
  • doc/Doxyfile.in

    r379 r803  
    1 # Doxyfile 1.5.7.1
     1# Doxyfile 1.5.9
    22
    33#---------------------------------------------------------------------------
     
    2222QT_AUTOBRIEF           = NO
    2323MULTILINE_CPP_IS_BRIEF = NO
    24 DETAILS_AT_TOP         = YES
    2524INHERIT_DOCS           = NO
    2625SEPARATE_MEMBER_PAGES  = NO
     
    9291                         "@abs_top_srcdir@/demo" \
    9392                         "@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"
    9595INPUT_ENCODING         = UTF-8
    9696FILE_PATTERNS          = *.h \
     
    224224SKIP_FUNCTION_MACROS   = YES
    225225#---------------------------------------------------------------------------
    226 # Configuration::additions related to external references   
     226# Options related to the search engine   
    227227#---------------------------------------------------------------------------
    228228TAGFILES               = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/  "
  • doc/Makefile.am

    r720 r943  
    2828        connected_components.eps \
    2929        edge_biconnected_components.eps \
     30        matching.eps \
    3031        node_biconnected_components.eps \
     32        planar.eps \
    3133        strongly_connected_components.eps
    3234
     
    6769        fi
    6870
    69 html-local: $(DOC_PNG_IMAGES)
     71references.dox: doc/references.bib
     72        if test ${python_found} = yes; then \
     73          cd doc; \
     74          python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \
     75          cd ..; \
     76        else \
     77          echo; \
     78          echo "Python not found."; \
     79          echo; \
     80          exit 1; \
     81        fi
     82
     83html-local: $(DOC_PNG_IMAGES) references.dox
    7084        if test ${doxygen_found} = yes; then \
    7185          cd doc; \
  • doc/groups.dox

    r948 r953  
    281281
    282282/**
     283@defgroup geomdat Geometric Data Structures
     284@ingroup auxdat
     285\brief Geometric data structures implemented in LEMON.
     286
     287This 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
     301This group contains two dimensional data storages implemented in LEMON.
     302*/
     303
     304/**
    283305@defgroup algs Algorithms
    284306\brief This group contains the several algorithms
     
    295317
    296318This group contains the common graph search algorithms, namely
    297 \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.
    298321*/
    299322
     
    303326\brief Algorithms for finding shortest paths.
    304327
    305 This group contains the algorithms for finding shortest paths in digraphs.
     328This group contains the algorithms for finding shortest paths in digraphs
     329\ref clrs01algorithms.
    306330
    307331 - \ref Dijkstra algorithm for finding shortest paths from a source node
     
    320344
    321345/**
     346@defgroup spantree Minimum Spanning Tree Algorithms
     347@ingroup algs
     348\brief Algorithms for finding minimum cost spanning trees and arborescences.
     349
     350This group contains the algorithms for finding minimum cost spanning
     351trees and arborescences \ref clrs01algorithms.
     352*/
     353
     354/**
    322355@defgroup max_flow Maximum Flow Algorithms
    323356@ingroup algs
     
    325358
    326359This group contains the algorithms for finding maximum flows and
    327 feasible circulations.
     360feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
    328361
    329362The \e maximum \e flow \e problem is to find a flow of maximum value between
     
    340373
    341374LEMON contains several algorithms for solving maximum flow problems:
    342 - \ref EdmondsKarp Edmonds-Karp algorithm.
    343 - \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.
    344 - \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.
    345 - \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.
    346 
    347 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
     384In most cases the \ref Preflow algorithm provides the
    348385fastest method for computing a maximum flow. All implementations
    349386also provide functions to query the minimum cut, which is the dual
     
    363400
    364401This group contains the algorithms for finding minimum cost flows and
    365 circulations. For more information about this problem and its dual
    366 solution see \ref min_cost_flow "Minimum Cost Flow Problem".
     402circulations \ref amo93networkflows. For more information about this
     403problem and its dual solution, see \ref min_cost_flow
     404"Minimum Cost Flow Problem".
    367405
    368406LEMON contains several algorithms for this problem.
    369407 - \ref NetworkSimplex Primal Network Simplex algorithm with various
    370    pivot strategies.
    371  - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
    372    cost scaling.
    373  - \ref CapacityScaling Successive Shortest %Path algorithm with optional
    374    capacity scaling.
    375  - \ref CancelAndTighten The Cancel and Tighten algorithm.
    376  - \ref CycleCanceling Cycle-Canceling algorithms.
     408   pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
     409 - \ref CostScaling Cost Scaling algorithm based on push/augment and
     410   relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
     411   \ref bunnagel98efficient.
     412 - \ref CapacityScaling Capacity Scaling algorithm based on the successive
     413   shortest path method \ref edmondskarp72theoretical.
     414 - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
     415   strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
    377416
    378417In general NetworkSimplex is the most efficient implementation,
     
    397436
    398437\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
    399     \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
     438    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
    400439
    401440LEMON contains several algorithms related to minimum cut problems:
     
    413452
    414453/**
    415 @defgroup graph_properties Connectivity and Other Graph Properties
    416 @ingroup algs
    417 \brief Algorithms for discovering the graph properties
    418 
    419 This group contains the algorithms for discovering the graph properties
    420 like connectivity, bipartiteness, euler property, simplicity etc.
    421 
    422 \image html edge_biconnected_components.png
    423 \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
    424 */
    425 
    426 /**
    427 @defgroup planar Planarity Embedding and Drawing
    428 @ingroup algs
    429 \brief Algorithms for planarity checking, embedding and drawing
    430 
    431 This group contains the algorithms for planarity checking,
    432 embedding and drawing.
    433 
    434 \image html planar.png
    435 \image latex planar.eps "Plane graph" width=\textwidth
     454@defgroup min_mean_cycle Minimum Mean Cycle Algorithms
     455@ingroup algs
     456\brief Algorithms for finding minimum mean cycles.
     457
     458This group contains the algorithms for finding minimum mean cycles
     459\ref clrs01algorithms, \ref amo93networkflows.
     460
     461The \e minimum \e mean \e cycle \e problem is to find a directed cycle
     462of minimum mean length (cost) in a digraph.
     463The mean length of a cycle is the average length of its arcs, i.e. the
     464ratio between the total length of the cycle and the number of arcs on it.
     465
     466This problem has an important connection to \e conservative \e length
     467\e functions, too. A length function on the arcs of a digraph is called
     468conservative if and only if there is no directed cycle of negative total
     469length. For an arbitrary length function, the negative of the minimum
     470cycle mean is the smallest \f$\epsilon\f$ value so that increasing the
     471arc lengths uniformly by \f$\epsilon\f$ results in a conservative length
     472function.
     473
     474LEMON contains three algorithms for solving the minimum mean cycle problem:
     475- \ref Karp "Karp"'s original algorithm \ref amo93networkflows,
     476  \ref dasdan98minmeancycle.
     477- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved
     478  version of Karp's algorithm \ref dasdan98minmeancycle.
     479- \ref Howard "Howard"'s policy iteration algorithm
     480  \ref dasdan98minmeancycle.
     481
     482In practice, the Howard algorithm proved to be by far the most efficient
     483one, though the best known theoretical bound on its running time is
     484exponential.
     485Both Karp and HartmannOrlin algorithms run in time O(ne) and use space
     486O(n<sup>2</sup>+e), but the latter one is typically faster due to the
     487applied early termination scheme.
    436488*/
    437489
     
    479531  perfect fractional matching in general graphs.
    480532
    481 \image html bipartite_matching.png
    482 \image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
    483 */
    484 
    485 /**
    486 @defgroup spantree Minimum Spanning Tree Algorithms
    487 @ingroup algs
    488 \brief Algorithms for finding minimum cost spanning trees and arborescences.
    489 
    490 This group contains the algorithms for finding minimum cost spanning
    491 trees and arborescences.
     533\image html matching.png
     534\image latex matching.eps "Min Cost Perfect Matching" width=\textwidth
     535*/
     536
     537/**
     538@defgroup graph_properties Connectivity and Other Graph Properties
     539@ingroup algs
     540\brief Algorithms for discovering the graph properties
     541
     542This group contains the algorithms for discovering the graph properties
     543like connectivity, bipartiteness, euler property, simplicity etc.
     544
     545\image html connected_components.png
     546\image latex connected_components.eps "Connected components" width=\textwidth
     547*/
     548
     549/**
     550@defgroup planar Planarity Embedding and Drawing
     551@ingroup algs
     552\brief Algorithms for planarity checking, embedding and drawing
     553
     554This group contains the algorithms for planarity checking,
     555embedding and drawing.
     556
     557\image html planar.png
     558\image latex planar.eps "Plane graph" width=\textwidth
     559*/
     560
     561/**
     562@defgroup approx Approximation Algorithms
     563@ingroup algs
     564\brief Approximation algorithms.
     565
     566This group contains the approximation and heuristic algorithms
     567implemented in LEMON.
    492568*/
    493569
     
    499575This group contains some algorithms implemented in LEMON
    500576in order to make it easier to implement complex algorithms.
    501 */
    502 
    503 /**
    504 @defgroup approx Approximation Algorithms
    505 @ingroup algs
    506 \brief Approximation algorithms.
    507 
    508 This group contains the approximation and heuristic algorithms
    509 implemented in LEMON.
    510577*/
    511578
     
    520587
    521588/**
    522 @defgroup lp_group Lp and Mip Solvers
     589@defgroup lp_group LP and MIP Solvers
    523590@ingroup gen_opt_group
    524 \brief Lp and Mip solver interfaces for LEMON.
    525 
    526 This group contains Lp and Mip solver interfaces for LEMON. The
    527 various LP solvers could be used in the same manner with this
    528 interface.
     591\brief LP and MIP solver interfaces for LEMON.
     592
     593This group contains LP and MIP solver interfaces for LEMON.
     594Various LP solvers could be used in the same manner with this
     595high-level interface.
     596
     597The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
     598\ref cplex, \ref soplex.
    529599*/
    530600
     
    616686
    617687/**
    618 @defgroup dimacs_group DIMACS format
     688@defgroup dimacs_group DIMACS Format
    619689@ingroup io_group
    620690\brief Read and write files in DIMACS format
     
    665735\brief Skeleton and concept checking classes for graph structures
    666736
    667 This group contains the skeletons and concept checking classes of LEMON's
    668 graph structures and helper classes used to implement these.
     737This group contains the skeletons and concept checking classes of
     738graph structures.
    669739*/
    670740
     
    678748
    679749/**
     750@defgroup tools Standalone Utility Applications
     751
     752Some utility applications are listed here.
     753
     754The standard compilation procedure (<tt>./configure;make</tt>) will compile
     755them, as well.
     756*/
     757
     758/**
    680759\anchor demoprograms
    681760
     
    689768*/
    690769
    691 /**
    692 @defgroup tools Standalone Utility Applications
    693 
    694 Some utility applications are listed here.
    695 
    696 The standard compilation procedure (<tt>./configure;make</tt>) will compile
    697 them, as well.
    698 */
    699 
    700770}
  • doc/mainpage.dox

    r705 r921  
    2222\section intro Introduction
    2323
    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
     25and <b>O</b>ptimization in <b>N</b>etworks</i>.
     26It is a C++ template library providing efficient implementations of common
     27data structures and algorithms with focus on combinatorial optimization
     28tasks connected mainly with graphs and networks.
    3229
    3330<b>
     
    3936</b>
    4037
    41 \subsection howtoread How to read the documentation
     38The project is maintained by the
     39<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
     40Combinatorial Optimization</a> \ref egres
     41at the Operations Research Department of the
     42<a href="http://www.elte.hu/en/">E&ouml;tv&ouml;s Lor&aacute;nd University</a>,
     43Budapest, Hungary.
     44LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
     45initiative \ref coinor.
     46
     47\section howtoread How to Read the Documentation
    4248
    4349If you would like to get to know the library, see
    4450<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
     51
     52If you are interested in starting to use the library, see the <a class="el"
     53href="http://lemon.cs.elte.hu/trac/lemon/wiki/InstallGuide/">Installation
     54Guide</a>.
    4555
    4656If you know what you are looking for, then try to find it under the
  • doc/min_cost_flow.dox

    r710 r835  
    2727minimum total cost from a set of supply nodes to a set of demand nodes
    2828in a network with capacity constraints (lower and upper bounds)
    29 and arc costs.
     29and arc costs \ref amo93networkflows.
    3030
    3131Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
     
    7979   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
    8080 - For all \f$u\in V\f$ nodes:
    81    - \f$\pi(u)<=0\f$;
     81   - \f$\pi(u)\leq 0\f$;
    8282   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
    8383     then \f$\pi(u)=0\f$.
     
    146146   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
    147147 - For all \f$u\in V\f$ nodes:
    148    - \f$\pi(u)>=0\f$;
     148   - \f$\pi(u)\geq 0\f$;
    149149   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
    150150     then \f$\pi(u)=0\f$.
  • lemon/Makefile.am

    r948 r953  
    6161        lemon/bfs.h \
    6262        lemon/bin_heap.h \
    63         lemon/binom_heap.h \
     63        lemon/binomial_heap.h \
    6464        lemon/bucket_heap.h \
     65        lemon/capacity_scaling.h \
    6566        lemon/cbc.h \
    6667        lemon/circulation.h \
     
    6970        lemon/concept_check.h \
    7071        lemon/connectivity.h \
     72        lemon/core.h \
     73        lemon/cost_scaling.h \
    7174        lemon/counter.h \
    72         lemon/core.h \
    7375        lemon/cplex.h \
     76        lemon/cycle_canceling.h \
    7477        lemon/dfs.h \
     78        lemon/dheap.h \
    7579        lemon/dijkstra.h \
    7680        lemon/dim2.h \
     
    8185        lemon/euler.h \
    8286        lemon/fib_heap.h \
    83         lemon/fourary_heap.h \
    8487        lemon/fractional_matching.h \
    8588        lemon/full_graph.h \
     
    8891        lemon/graph_to_eps.h \
    8992        lemon/grid_graph.h \
     93        lemon/hartmann_orlin_mmc.h \
     94        lemon/howard_mmc.h \
    9095        lemon/hypercube_graph.h \
    91         lemon/kary_heap.h \
     96        lemon/karp_mmc.h \
    9297        lemon/kruskal.h \
    9398        lemon/hao_orlin.h \
     
    106111        lemon/pairing_heap.h \
    107112        lemon/path.h \
     113        lemon/planarity.h \
    108114        lemon/preflow.h \
     115        lemon/quad_heap.h \
    109116        lemon/radix_heap.h \
    110117        lemon/radix_sort.h \
     
    112119        lemon/smart_graph.h \
    113120        lemon/soplex.h \
     121        lemon/static_graph.h \
    114122        lemon/suurballe.h \
    115123        lemon/time_measure.h \
  • lemon/adaptors.h

    r703 r834  
    361361  /// parameter is set to be \c const.
    362362  ///
     363  /// This class provides item counting in the same time as the adapted
     364  /// digraph structure.
     365  ///
    363366  /// \tparam DGR The type of the adapted digraph.
    364367  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
     
    719722  /// by adding or removing nodes or arcs, unless the \c GR template
    720723  /// parameter is set to be \c const.
     724  ///
     725  /// This class provides only linear time counting for nodes and arcs.
    721726  ///
    722727  /// \tparam DGR The type of the adapted digraph.
     
    13151320  /// parameter is set to be \c const.
    13161321  ///
     1322  /// This class provides only linear time counting for nodes, edges and arcs.
     1323  ///
    13171324  /// \tparam GR The type of the adapted graph.
    13181325  /// It must conform to the \ref concepts::Graph "Graph" concept.
     
    14711478  /// by adding or removing nodes or arcs/edges, unless the \c GR template
    14721479  /// parameter is set to be \c const.
     1480  ///
     1481  /// This class provides only linear time item counting.
    14731482  ///
    14741483  /// \tparam GR The type of the adapted digraph or graph.
     
    16201629  /// parameter is set to be \c const.
    16211630  ///
     1631  /// This class provides only linear time counting for nodes and arcs.
     1632  ///
    16221633  /// \tparam DGR The type of the adapted digraph.
    16231634  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
     
    17291740  /// by adding or removing nodes or edges, unless the \c GR template
    17301741  /// parameter is set to be \c const.
     1742  ///
     1743  /// This class provides only linear time counting for nodes, edges and arcs.
    17311744  ///
    17321745  /// \tparam GR The type of the adapted graph.
     
    22332246  /// parameter is set to be \c const.
    22342247  ///
     2248  /// This class provides item counting in the same time as the adapted
     2249  /// digraph structure.
     2250  ///
    22352251  /// \tparam DGR The type of the adapted digraph.
    22362252  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
     
    25352551  /// by adding or removing nodes or arcs, unless the \c GR template
    25362552  /// parameter is set to be \c const.
     2553  ///
     2554  /// This class provides item counting in the same time as the adapted
     2555  /// graph structure.
    25372556  ///
    25382557  /// \tparam GR The type of the adapted graph.
     
    26782697  /// arcs).
    26792698  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
     2699  ///
     2700  /// This class provides only linear time counting for nodes and arcs.
    26802701  ///
    26812702  /// \tparam DGR The type of the adapted digraph.
     
    33263347  /// in the adaptor.
    33273348  ///
     3349  /// This class provides item counting in the same time as the adapted
     3350  /// digraph structure.
     3351  ///
    33283352  /// \tparam DGR The type of the adapted digraph.
    33293353  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
  • lemon/arg_parser.cc

    r463 r915  
    2121namespace lemon {
    2222
     23  void ArgParser::_terminate(ArgParserException::Reason reason) const
     24  {
     25    if(_exit_on_problems)
     26      exit(1);
     27    else throw(ArgParserException(reason));
     28  }
     29 
     30 
    2331  void ArgParser::_showHelp(void *p)
    2432  {
    2533    (static_cast<ArgParser*>(p))->showHelp();
    26     exit(1);
     34    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);
    2735  }
    2836
    2937  ArgParser::ArgParser(int argc, const char * const *argv)
    30     :_argc(argc), _argv(argv), _command_name(argv[0]) {
     38    :_argc(argc), _argv(argv), _command_name(argv[0]),
     39    _exit_on_problems(true) {
    3140    funcOption("-help","Print a short help message",_showHelp,this);
    3241    synonym("help","-help");
     
    343352        i!=_others_help.end();++i) showHelp(i);
    344353    for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
    345     exit(1);
     354    _terminate(ArgParserException::HELP);
    346355  }
    347356
     
    352361    std::cerr << "\nType '" << _command_name <<
    353362      " --help' to obtain a short summary on the usage.\n\n";
    354     exit(1);
     363    _terminate(ArgParserException::UNKNOWN_OPT);
    355364  }
    356365
     
    415424      std::cerr << "\nType '" << _command_name <<
    416425        " --help' to obtain a short summary on the usage.\n\n";
    417       exit(1);
     426      _terminate(ArgParserException::INVALID_OPT);
    418427    }
    419428  }
  • lemon/arg_parser.h

    r463 r915  
    3535namespace lemon {
    3636
     37  ///Exception used by ArgParser
     38  class ArgParserException : public Exception {
     39  public:
     40    enum Reason {
     41      HELP,         /// <tt>--help</tt> option was given
     42      UNKNOWN_OPT,  /// Unknown option was given
     43      INVALID_OPT   /// Invalid combination of options
     44    };
     45   
     46  private:
     47    Reason _reason;
     48   
     49  public:
     50    ///Constructor
     51    ArgParserException(Reason r) throw() : _reason(r) {}
     52    ///Virtual destructor
     53    virtual ~ArgParserException() throw() {}
     54    ///A short description of the exception
     55    virtual const char* what() const throw() {
     56      switch(_reason)
     57        {
     58        case HELP:
     59          return "lemon::ArgParseException: ask for help";
     60          break;
     61        case UNKNOWN_OPT:
     62          return "lemon::ArgParseException: unknown option";
     63          break;
     64        case INVALID_OPT:
     65          return "lemon::ArgParseException: invalid combination of options";
     66          break;
     67        }
     68      return "";
     69    }
     70    ///Return the reason for the failure
     71    Reason reason() const {return _reason; }
     72  };
     73
     74
    3775  ///Command line arguments parser
    3876
     
    104142    std::string _command_name;
    105143
    106 
     144   
    107145  private:
    108146    //Bind a function to an option.
     
    116154                    const std::string &help,
    117155                    void (*func)(void *),void *data);
     156
     157    bool _exit_on_problems;
     158   
     159    void _terminate(ArgParserException::Reason reason) const;
    118160
    119161  public:
     
    381423    const std::vector<std::string> &files() const { return _file_args; }
    382424
     425    ///Throw instead of exit in case of problems
     426    void throwOnProblems()
     427    {
     428      _exit_on_problems=false;
     429    }
    383430  };
    384431}
  • lemon/bellman_ford.h

    r746 r917  
    2424/// \brief Bellman-Ford algorithm.
    2525
     26#include <lemon/list_graph.h>
    2627#include <lemon/bits/path_dump.h>
    2728#include <lemon/core.h>
    2829#include <lemon/error.h>
    2930#include <lemon/maps.h>
     31#include <lemon/tolerance.h>
    3032#include <lemon/path.h>
    3133
     
    3436namespace lemon {
    3537
    36   /// \brief Default OperationTraits for the BellmanFord algorithm class.
     38  /// \brief Default operation traits for the BellmanFord algorithm class.
    3739  /// 
    3840  /// This operation traits class defines all computational operations
     
    4143  /// If the numeric type does not have infinity value, then the maximum
    4244  /// value is used as extremal infinity value.
     45  ///
     46  /// \see BellmanFordToleranceOperationTraits
    4347  template <
    4448    typename V,
    4549    bool has_inf = std::numeric_limits<V>::has_infinity>
    4650  struct BellmanFordDefaultOperationTraits {
    47     /// \e
     51    /// \brief Value type for the algorithm.
    4852    typedef V Value;
    4953    /// \brief Gives back the zero value of the type.
     
    8488  };
    8589 
     90  /// \brief Operation traits for the BellmanFord algorithm class
     91  /// using tolerance.
     92  ///
     93  /// This operation traits class defines all computational operations
     94  /// and constants that are used in the Bellman-Ford algorithm.
     95  /// The only difference between this implementation and
     96  /// \ref BellmanFordDefaultOperationTraits is that this class uses
     97  /// the \ref Tolerance "tolerance technique" in its \ref less()
     98  /// function.
     99  ///
     100  /// \tparam V The value type.
     101  /// \tparam eps The epsilon value for the \ref less() function.
     102  /// By default, it is the epsilon value used by \ref Tolerance
     103  /// "Tolerance<V>".
     104  ///
     105  /// \see BellmanFordDefaultOperationTraits
     106#ifdef DOXYGEN
     107  template <typename V, V eps>
     108#else
     109  template <
     110    typename V,
     111    V eps = Tolerance<V>::def_epsilon>
     112#endif
     113  struct BellmanFordToleranceOperationTraits {
     114    /// \brief Value type for the algorithm.
     115    typedef V Value;
     116    /// \brief Gives back the zero value of the type.
     117    static Value zero() {
     118      return static_cast<Value>(0);
     119    }
     120    /// \brief Gives back the positive infinity value of the type.
     121    static Value infinity() {
     122      return std::numeric_limits<Value>::infinity();
     123    }
     124    /// \brief Gives back the sum of the given two elements.
     125    static Value plus(const Value& left, const Value& right) {
     126      return left + right;
     127    }
     128    /// \brief Gives back \c true only if the first value is less than
     129    /// the second.
     130    static bool less(const Value& left, const Value& right) {
     131      return left + eps < right;
     132    }
     133  };
     134
    86135  /// \brief Default traits class of BellmanFord class.
    87136  ///
     
    107156    /// It defines the used operations and the infinity value for the
    108157    /// given \c Value type.
    109     /// \see BellmanFordDefaultOperationTraits
     158    /// \see BellmanFordDefaultOperationTraits,
     159    /// BellmanFordToleranceOperationTraits
    110160    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
    111161 
     
    171221  /// the lengths of the arcs. The default map type is
    172222  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
     223  /// \tparam TR The traits class that defines various types used by the
     224  /// algorithm. By default, it is \ref BellmanFordDefaultTraits
     225  /// "BellmanFordDefaultTraits<GR, LEN>".
     226  /// In most cases, this parameter should not be set directly,
     227  /// consider to use the named template parameters instead.
    173228#ifdef DOXYGEN
    174229  template <typename GR, typename LEN, typename TR>
     
    237292        _dist = Traits::createDistMap(*_gr);
    238293      }
    239       _mask = new MaskMap(*_gr, false);
     294      if(!_mask) {
     295        _mask = new MaskMap(*_gr);
     296      }
    240297    }
    241298   
     
    300357    /// \ref named-templ-param "Named parameter" for setting
    301358    /// \c OperationTraits type.
    302     /// For more information see \ref BellmanFordDefaultOperationTraits.
     359    /// For more information, see \ref BellmanFordDefaultOperationTraits.
    303360    template <class T>
    304361    struct SetOperationTraits
     
    403460          _process.push_back(it);
    404461          _mask->set(it, true);
     462        }
     463      } else {
     464        for (NodeIt it(*_gr); it != INVALID; ++it) {
     465          _mask->set(it, false);
    405466        }
    406467      }
     
    718779    ///
    719780    /// The shortest path tree used here is equal to the shortest path
    720     /// tree used in \ref predNode() and \predMap().
     781    /// tree used in \ref predNode() and \ref predMap().
    721782    ///
    722783    /// \pre Either \ref run() or \ref init() must be called before
     
    733794    ///
    734795    /// The shortest path tree used here is equal to the shortest path
    735     /// tree used in \ref predArc() and \predMap().
     796    /// tree used in \ref predArc() and \ref predMap().
    736797    ///
    737798    /// \pre Either \ref run() or \ref init() must be called before
     
    776837    /// length if the algorithm has already found one.
    777838    /// Otherwise it gives back an empty path.
    778     lemon::Path<Digraph> negativeCycle() {
     839    lemon::Path<Digraph> negativeCycle() const {
    779840      typename Digraph::template NodeMap<int> state(*_gr, -1);
    780841      lemon::Path<Digraph> cycle;
     
    826887    /// It defines the used operations and the infinity value for the
    827888    /// given \c Value type.
    828     /// \see BellmanFordDefaultOperationTraits
     889    /// \see BellmanFordDefaultOperationTraits,
     890    /// BellmanFordToleranceOperationTraits
    829891    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
    830892
     
    927989  /// This class should only be used through the \ref bellmanFord()
    928990  /// function, which makes it easier to use the algorithm.
     991  ///
     992  /// \tparam TR The traits class that defines various types used by the
     993  /// algorithm.
    929994  template<class TR>
    930995  class BellmanFordWizard : public TR {
  • lemon/bfs.h

    r525 r891  
    4848    ///The type of the map that stores the predecessor
    4949    ///arcs of the shortest paths.
    50     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     50    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    5252    ///Instantiates a \c PredMap.
     
    6363
    6464    ///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.
    6667    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6768    ///Instantiates a \c ProcessedMap.
     
    8283
    8384    ///The type of the map that indicates which nodes are reached.
    84     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     85    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8586    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    8687    ///Instantiates a \c ReachedMap.
     
    9798
    9899    ///The type of the map that stores the distances of the nodes.
    99     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     100    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    100101    typedef typename Digraph::template NodeMap<int> DistMap;
    101102    ///Instantiates a \c DistMap.
     
    121122  ///\tparam GR The type of the digraph the algorithm runs on.
    122123  ///The default type is \ref ListDigraph.
     124  ///\tparam TR The traits class that defines various types used by the
     125  ///algorithm. By default, it is \ref BfsDefaultTraits
     126  ///"BfsDefaultTraits<GR>".
     127  ///In most cases, this parameter should not be set directly,
     128  ///consider to use the named template parameters instead.
    123129#ifdef DOXYGEN
    124130  template <typename GR,
     
    226232    ///\ref named-templ-param "Named parameter" for setting
    227233    ///\c PredMap type.
    228     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     234    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    229235    template <class T>
    230236    struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
     
    246252    ///\ref named-templ-param "Named parameter" for setting
    247253    ///\c DistMap type.
    248     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     254    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    249255    template <class T>
    250256    struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
     
    266272    ///\ref named-templ-param "Named parameter" for setting
    267273    ///\c ReachedMap type.
    268     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     274    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    269275    template <class T>
    270276    struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
     
    286292    ///\ref named-templ-param "Named parameter" for setting
    287293    ///\c ProcessedMap type.
    288     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     294    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    289295    template <class T>
    290296    struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
     
    414420    ///The simplest way to execute the BFS algorithm is to use one of the
    415421    ///member functions called \ref run(Node) "run()".\n
    416     ///If you need more control on the execution, first you have to call
    417     ///\ref init(), then you can add several source nodes with
     422    ///If you need better control on the execution, you have to call
     423    ///\ref init() first, then you can add several source nodes with
    418424    ///\ref addSource(). Finally the actual path computation can be
    419425    ///performed with one of the \ref start() functions.
     
    701707    ///Runs the algorithm to visit all nodes in the digraph.
    702708
    703     ///This method runs the %BFS algorithm in order to
    704     ///compute the shortest path to each node.
    705     ///
    706     ///The algorithm computes
    707     ///- the shortest path tree (forest),
    708     ///- the distance of each node from the root(s).
     709    ///This method runs the %BFS algorithm in order to visit all nodes
     710    ///in the digraph.
    709711    ///
    710712    ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
     
    738740    ///@{
    739741
    740     ///The shortest path to a node.
    741 
    742     ///Returns the shortest path to a node.
     742    ///The shortest path to the given node.
     743
     744    ///Returns the shortest path to the given node from the root(s).
    743745    ///
    744746    ///\warning \c t should be reached from the root(s).
     
    748750    Path path(Node t) const { return Path(*G, *_pred, t); }
    749751
    750     ///The distance of a node from the root(s).
    751 
    752     ///Returns the distance of a node from the root(s).
     752    ///The distance of the given node from the root(s).
     753
     754    ///Returns the distance of the given node from the root(s).
    753755    ///
    754756    ///\warning If node \c v is not reached from the root(s), then
     
    759761    int dist(Node v) const { return (*_dist)[v]; }
    760762
    761     ///Returns the 'previous arc' of the shortest path tree for a node.
    762 
     763    ///\brief Returns the 'previous arc' of the shortest path tree for
     764    ///the given node.
     765    ///
    763766    ///This function returns the 'previous arc' of the shortest path
    764767    ///tree for the node \c v, i.e. it returns the last arc of a
     
    767770    ///
    768771    ///The shortest path tree used here is equal to the shortest path
    769     ///tree used in \ref predNode().
     772    ///tree used in \ref predNode() and \ref predMap().
    770773    ///
    771774    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    773776    Arc predArc(Node v) const { return (*_pred)[v];}
    774777
    775     ///Returns the 'previous node' of the shortest path tree for a node.
    776 
     778    ///\brief Returns the 'previous node' of the shortest path tree for
     779    ///the given node.
     780    ///
    777781    ///This function returns the 'previous node' of the shortest path
    778782    ///tree for the node \c v, i.e. it returns the last but one node
    779     ///from a shortest path from a root to \c v. It is \c INVALID
     783    ///of a shortest path from a root to \c v. It is \c INVALID
    780784    ///if \c v is not reached from the root(s) or if \c v is a root.
    781785    ///
    782786    ///The shortest path tree used here is equal to the shortest path
    783     ///tree used in \ref predArc().
     787    ///tree used in \ref predArc() and \ref predMap().
    784788    ///
    785789    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    802806    ///
    803807    ///Returns a const reference to the node map that stores the predecessor
    804     ///arcs, which form the shortest path tree.
     808    ///arcs, which form the shortest path tree (forest).
    805809    ///
    806810    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    808812    const PredMap &predMap() const { return *_pred;}
    809813
    810     ///Checks if a node is reached from the root(s).
     814    ///Checks if the given node is reached from the root(s).
    811815
    812816    ///Returns \c true if \c v is reached from the root(s).
     
    834838    ///The type of the map that stores the predecessor
    835839    ///arcs of the shortest paths.
    836     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     840    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    837841    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    838842    ///Instantiates a PredMap.
     
    849853
    850854    ///The type of the map that indicates which nodes are processed.
    851     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    852     ///By default it is a NullMap.
     855    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     856    ///By default, it is a NullMap.
    853857    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    854858    ///Instantiates a ProcessedMap.
     
    869873
    870874    ///The type of the map that indicates which nodes are reached.
    871     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     875    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    872876    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    873877    ///Instantiates a ReachedMap.
     
    884888
    885889    ///The type of the map that stores the distances of the nodes.
    886     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     890    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    887891    typedef typename Digraph::template NodeMap<int> DistMap;
    888892    ///Instantiates a DistMap.
     
    899903
    900904    ///The type of the shortest paths.
    901     ///It must meet the \ref concepts::Path "Path" concept.
     905    ///It must conform to the \ref concepts::Path "Path" concept.
    902906    typedef lemon::Path<Digraph> Path;
    903907  };
     
    905909  /// Default traits class used by BfsWizard
    906910
    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.
     911  /// Default traits class used by BfsWizard.
     912  /// \tparam GR The type of the digraph.
    913913  template<class GR>
    914914  class BfsWizardBase : public BfsWizardDefaultTraits<GR>
     
    938938    /// Constructor.
    939939
    940     /// This constructor does not require parameters, therefore it initiates
     940    /// This constructor does not require parameters, it initiates
    941941    /// all of the attributes to \c 0.
    942942    BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
     
    963963  /// This class should only be used through the \ref bfs() function,
    964964  /// which makes it easier to use the algorithm.
     965  ///
     966  /// \tparam TR The traits class that defines various types used by the
     967  /// algorithm.
    965968  template<class TR>
    966969  class BfsWizard : public TR
     
    968971    typedef TR Base;
    969972
    970     ///The type of the digraph the algorithm runs on.
    971973    typedef typename TR::Digraph Digraph;
    972974
     
    976978    typedef typename Digraph::OutArcIt OutArcIt;
    977979
    978     ///\brief The type of the map that stores the predecessor
    979     ///arcs of the shortest paths.
    980980    typedef typename TR::PredMap PredMap;
    981     ///\brief The type of the map that stores the distances of the nodes.
    982981    typedef typename TR::DistMap DistMap;
    983     ///\brief The type of the map that indicates which nodes are reached.
    984982    typedef typename TR::ReachedMap ReachedMap;
    985     ///\brief The type of the map that indicates which nodes are processed.
    986983    typedef typename TR::ProcessedMap ProcessedMap;
    987     ///The type of the shortest paths
    988984    typedef typename TR::Path Path;
    989985
     
    10551051    ///Runs BFS algorithm to visit all nodes in the digraph.
    10561052
    1057     ///This method runs BFS algorithm in order to compute
    1058     ///the shortest path to each node.
     1053    ///This method runs BFS algorithm in order to visit all nodes
     1054    ///in the digraph.
    10591055    void run()
    10601056    {
     
    10681064      SetPredMapBase(const TR &b) : TR(b) {}
    10691065    };
    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.
     1066
     1067    ///\brief \ref named-templ-param "Named parameter" for setting
     1068    ///the predecessor map.
     1069    ///
     1070    ///\ref named-templ-param "Named parameter" function for setting
     1071    ///the map that stores the predecessor arcs of the nodes.
    10751072    template<class T>
    10761073    BfsWizard<SetPredMapBase<T> > predMap(const T &t)
     
    10861083      SetReachedMapBase(const TR &b) : TR(b) {}
    10871084    };
    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.
     1085
     1086    ///\brief \ref named-templ-param "Named parameter" for setting
     1087    ///the reached map.
     1088    ///
     1089    ///\ref named-templ-param "Named parameter" function for setting
     1090    ///the map that indicates which nodes are reached.
    10931091    template<class T>
    10941092    BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
     
    11041102      SetDistMapBase(const TR &b) : TR(b) {}
    11051103    };
    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.
     1104
     1105    ///\brief \ref named-templ-param "Named parameter" for setting
     1106    ///the distance map.
     1107    ///
     1108    ///\ref named-templ-param "Named parameter" function for setting
     1109    ///the map that stores the distances of the nodes calculated
     1110    ///by the algorithm.
    11111111    template<class T>
    11121112    BfsWizard<SetDistMapBase<T> > distMap(const T &t)
     
    11221122      SetProcessedMapBase(const TR &b) : TR(b) {}
    11231123    };
    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.
     1124
     1125    ///\brief \ref named-func-param "Named parameter" for setting
     1126    ///the processed map.
     1127    ///
     1128    ///\ref named-templ-param "Named parameter" function for setting
     1129    ///the map that indicates which nodes are processed.
    11291130    template<class T>
    11301131    BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     
    12651266    ///
    12661267    /// The type of the map that indicates which nodes are reached.
    1267     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     1268    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    12681269    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    12691270
     
    13031304  /// does not observe the BFS events. If you want to observe the BFS
    13041305  /// events, you should implement your own visitor class.
    1305   /// \tparam TR Traits class to set various data types used by the
    1306   /// algorithm. The default traits class is
    1307   /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
    1308   /// See \ref BfsVisitDefaultTraits for the documentation of
    1309   /// a BFS visit traits class.
     1306  /// \tparam TR The traits class that defines various types used by the
     1307  /// algorithm. By default, it is \ref BfsVisitDefaultTraits
     1308  /// "BfsVisitDefaultTraits<GR>".
     1309  /// In most cases, this parameter should not be set directly,
     1310  /// consider to use the named template parameters instead.
    13101311#ifdef DOXYGEN
    13111312  template <typename GR, typename VS, typename TR>
     
    14261427    /// The simplest way to execute the BFS algorithm is to use one of the
    14271428    /// member functions called \ref run(Node) "run()".\n
    1428     /// If you need more control on the execution, first you have to call
    1429     /// \ref init(), then you can add several source nodes with
     1429    /// If you need better control on the execution, you have to call
     1430    /// \ref init() first, then you can add several source nodes with
    14301431    /// \ref addSource(). Finally the actual path computation can be
    14311432    /// performed with one of the \ref start() functions.
     
    16991700    /// \brief Runs the algorithm to visit all nodes in the digraph.
    17001701    ///
    1701     /// This method runs the %BFS algorithm in order to
    1702     /// compute the shortest path to each node.
    1703     ///
    1704     /// The algorithm computes
    1705     /// - the shortest path tree (forest),
    1706     /// - the distance of each node from the root(s).
     1702    /// This method runs the %BFS algorithm in order to visit all nodes
     1703    /// in the digraph.
    17071704    ///
    17081705    /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.
     
    17361733    ///@{
    17371734
    1738     /// \brief Checks if a node is reached from the root(s).
     1735    /// \brief Checks if the given node is reached from the root(s).
    17391736    ///
    17401737    /// Returns \c true if \c v is reached from the root(s).
  • lemon/bits/graph_extender.h

    r732 r825  
    5757    }
    5858
    59     Node fromId(int id, Node) const {
     59    static Node fromId(int id, Node) {
    6060      return Parent::nodeFromId(id);
    6161    }
    6262
    63     Arc fromId(int id, Arc) const {
     63    static Arc fromId(int id, Arc) {
    6464      return Parent::arcFromId(id);
    6565    }
     
    356356    }
    357357
    358     Node fromId(int id, Node) const {
     358    static Node fromId(int id, Node) {
    359359      return Parent::nodeFromId(id);
    360360    }
    361361
    362     Arc fromId(int id, Arc) const {
     362    static Arc fromId(int id, Arc) {
    363363      return Parent::arcFromId(id);
    364364    }
    365365
    366     Edge fromId(int id, Edge) const {
     366    static Edge fromId(int id, Edge) {
    367367      return Parent::edgeFromId(id);
    368368    }
  • lemon/bits/map_extender.h

    r664 r867  
    5050    typedef typename Parent::ConstReference ConstReference;
    5151
     52    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
     53
    5254    class MapIt;
    5355    class ConstMapIt;
     
    8385      typedef typename Map::Value Value;
    8486
    85       MapIt() {}
    86 
    87       MapIt(Invalid i) : Parent(i) { }
    88 
    89       explicit MapIt(Map& _map) : map(_map) {
    90         map.notifier()->first(*this);
     87      MapIt() : map(NULL) {}
     88
     89      MapIt(Invalid i) : Parent(i), map(NULL) {}
     90
     91      explicit MapIt(Map& _map) : map(&_map) {
     92        map->notifier()->first(*this);
    9193      }
    9294
    9395      MapIt(const Map& _map, const Item& item)
     96        : Parent(item), map(&_map) {}
     97
     98      MapIt& operator++() {
     99        map->notifier()->next(*this);
     100        return *this;
     101      }
     102
     103      typename MapTraits<Map>::ConstReturnValue operator*() const {
     104        return (*map)[*this];
     105      }
     106
     107      typename MapTraits<Map>::ReturnValue operator*() {
     108        return (*map)[*this];
     109      }
     110
     111      void set(const Value& value) {
     112        map->set(*this, value);
     113      }
     114
     115    protected:
     116      Map* map;
     117
     118    };
     119
     120    class ConstMapIt : public Item {
     121      typedef Item Parent;
     122
     123    public:
     124
     125      typedef typename Map::Value Value;
     126
     127      ConstMapIt() : map(NULL) {}
     128
     129      ConstMapIt(Invalid i) : Parent(i), map(NULL) {}
     130
     131      explicit ConstMapIt(Map& _map) : map(&_map) {
     132        map->notifier()->first(*this);
     133      }
     134
     135      ConstMapIt(const Map& _map, const Item& item)
    94136        : Parent(item), map(_map) {}
    95137
    96       MapIt& operator++() {
    97         map.notifier()->next(*this);
     138      ConstMapIt& operator++() {
     139        map->notifier()->next(*this);
    98140        return *this;
    99141      }
     
    103145      }
    104146
    105       typename MapTraits<Map>::ReturnValue operator*() {
    106         return map[*this];
    107       }
    108 
    109       void set(const Value& value) {
    110         map.set(*this, value);
    111       }
    112 
    113     protected:
    114       Map& map;
    115 
    116     };
    117 
    118     class ConstMapIt : public Item {
    119       typedef Item Parent;
    120 
    121     public:
    122 
    123       typedef typename Map::Value Value;
    124 
    125       ConstMapIt() {}
    126 
    127       ConstMapIt(Invalid i) : Parent(i) { }
    128 
    129       explicit ConstMapIt(Map& _map) : map(_map) {
    130         map.notifier()->first(*this);
    131       }
    132 
    133       ConstMapIt(const Map& _map, const Item& item)
    134         : Parent(item), map(_map) {}
    135 
    136       ConstMapIt& operator++() {
    137         map.notifier()->next(*this);
    138         return *this;
    139       }
    140 
    141       typename MapTraits<Map>::ConstReturnValue operator*() const {
    142         return map[*this];
    143       }
    144 
    145     protected:
    146       const Map& map;
     147    protected:
     148      const Map* map;
    147149    };
    148150
     
    151153
    152154    public:
    153 
    154       ItemIt() {}
    155 
    156       ItemIt(Invalid i) : Parent(i) { }
    157 
    158       explicit ItemIt(Map& _map) : map(_map) {
    159         map.notifier()->first(*this);
     155      ItemIt() : map(NULL) {}
     156
     157
     158      ItemIt(Invalid i) : Parent(i), map(NULL) {}
     159
     160      explicit ItemIt(Map& _map) : map(&_map) {
     161        map->notifier()->first(*this);
    160162      }
    161163
    162164      ItemIt(const Map& _map, const Item& item)
    163         : Parent(item), map(_map) {}
     165        : Parent(item), map(&_map) {}
    164166
    165167      ItemIt& operator++() {
    166         map.notifier()->next(*this);
    167         return *this;
    168       }
    169 
    170     protected:
    171       const Map& map;
     168        map->notifier()->next(*this);
     169        return *this;
     170      }
     171
     172    protected:
     173      const Map* map;
    172174
    173175    };
     
    192194    typedef typename Parent::ConstReference ConstReference;
    193195
     196    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
     197
    194198    class MapIt;
    195199    class ConstMapIt;
     
    228232      typedef typename Map::Value Value;
    229233
    230       MapIt() {}
    231 
    232       MapIt(Invalid i) : Parent(i) { }
    233 
    234       explicit MapIt(Map& _map) : map(_map) {
    235         map.graph.first(*this);
     234      MapIt() : map(NULL) {}
     235
     236      MapIt(Invalid i) : Parent(i), map(NULL) { }
     237
     238      explicit MapIt(Map& _map) : map(&_map) {
     239        map->graph.first(*this);
    236240      }
    237241
    238242      MapIt(const Map& _map, const Item& item)
    239         : Parent(item), map(_map) {}
     243        : Parent(item), map(&_map) {}
    240244
    241245      MapIt& operator++() {
    242         map.graph.next(*this);
     246        map->graph.next(*this);
    243247        return *this;
    244248      }
    245249
    246250      typename MapTraits<Map>::ConstReturnValue operator*() const {
    247         return map[*this];
     251        return (*map)[*this];
    248252      }
    249253
    250254      typename MapTraits<Map>::ReturnValue operator*() {
    251         return map[*this];
     255        return (*map)[*this];
    252256      }
    253257
    254258      void set(const Value& value) {
    255         map.set(*this, value);
    256       }
    257 
    258     protected:
    259       Map& map;
     259        map->set(*this, value);
     260      }
     261
     262    protected:
     263      Map* map;
    260264
    261265    };
     
    268272      typedef typename Map::Value Value;
    269273
    270       ConstMapIt() {}
    271 
    272       ConstMapIt(Invalid i) : Parent(i) { }
    273 
    274       explicit ConstMapIt(Map& _map) : map(_map) {
    275         map.graph.first(*this);
     274      ConstMapIt() : map(NULL) {}
     275
     276      ConstMapIt(Invalid i) : Parent(i), map(NULL) { }
     277
     278      explicit ConstMapIt(Map& _map) : map(&_map) {
     279        map->graph.first(*this);
    276280      }
    277281
    278282      ConstMapIt(const Map& _map, const Item& item)
    279         : Parent(item), map(_map) {}
     283        : Parent(item), map(&_map) {}
    280284
    281285      ConstMapIt& operator++() {
    282         map.graph.next(*this);
     286        map->graph.next(*this);
    283287        return *this;
    284288      }
    285289
    286290      typename MapTraits<Map>::ConstReturnValue operator*() const {
    287         return map[*this];
    288       }
    289 
    290     protected:
    291       const Map& map;
     291        return (*map)[*this];
     292      }
     293
     294    protected:
     295      const Map* map;
    292296    };
    293297
     
    296300
    297301    public:
    298 
    299       ItemIt() {}
    300 
    301       ItemIt(Invalid i) : Parent(i) { }
    302 
    303       explicit ItemIt(Map& _map) : map(_map) {
    304         map.graph.first(*this);
     302      ItemIt() : map(NULL) {}
     303
     304
     305      ItemIt(Invalid i) : Parent(i), map(NULL) { }
     306
     307      explicit ItemIt(Map& _map) : map(&_map) {
     308        map->graph.first(*this);
    305309      }
    306310
    307311      ItemIt(const Map& _map, const Item& item)
    308         : Parent(item), map(_map) {}
     312        : Parent(item), map(&_map) {}
    309313
    310314      ItemIt& operator++() {
    311         map.graph.next(*this);
    312         return *this;
    313       }
    314 
    315     protected:
    316       const Map& map;
     315        map->graph.next(*this);
     316        return *this;
     317      }
     318
     319    protected:
     320      const Map* map;
    317321
    318322    };
  • lemon/cbc.cc

    r623 r793  
    9595  }
    9696
     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  }
    97109
    98110  void CbcMip::_eraseCol(int i) {
  • lemon/cbc.h

    r623 r793  
    6363    virtual int _addCol();
    6464    virtual int _addRow();
     65    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    6566
    6667    virtual void _eraseCol(int i);
  • lemon/circulation.h

    r736 r891  
    7373    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
    7474    /// concept.
     75#ifdef DOXYGEN
     76    typedef GR::ArcMap<Value> FlowMap;
     77#else
    7578    typedef typename Digraph::template ArcMap<Value> FlowMap;
     79#endif
    7680
    7781    /// \brief Instantiates a FlowMap.
     
    8892    /// The elevator type used by the algorithm.
    8993    ///
    90     /// \sa Elevator
    91     /// \sa LinkedElevator
     94    /// \sa Elevator, LinkedElevator
     95#ifdef DOXYGEN
     96    typedef lemon::Elevator<GR, GR::Node> Elevator;
     97#else
    9298    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
     99#endif
    93100
    94101    /// \brief Instantiates an Elevator.
     
    167174     \tparam SM The type of the supply map. The default map type is
    168175     \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
     176     \tparam TR The traits class that defines various types used by the
     177     algorithm. By default, it is \ref CirculationDefaultTraits
     178     "CirculationDefaultTraits<GR, LM, UM, SM>".
     179     In most cases, this parameter should not be set directly,
     180     consider to use the named template parameters instead.
    169181  */
    170182#ifdef DOXYGEN
     
    300312    /// able to automatically created by the algorithm (i.e. the
    301313    /// digraph and the maximum level should be passed to it).
    302     /// However an external elevator object could also be passed to the
     314    /// However, an external elevator object could also be passed to the
    303315    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
    304316    /// before calling \ref run() or \ref init().
     
    470482    /// \name Execution Control
    471483    /// The simplest way to execute the algorithm is to call \ref run().\n
    472     /// If you need more control on the initial solution or the execution,
    473     /// first you have to call one of the \ref init() functions, then
     484    /// If you need better control on the initial solution or the execution,
     485    /// you have to call one of the \ref init() functions first, then
    474486    /// the \ref start() function.
    475487
  • lemon/clp.cc

    r623 r793  
    7979  }
    8080
     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
    8194
    8295  void ClpLp::_eraseCol(int c) {
  • lemon/clp.h

    r623 r793  
    7676    virtual int _addCol();
    7777    virtual int _addRow();
     78    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    7879
    7980    virtual void _eraseCol(int i);
  • lemon/concepts/digraph.h

    r627 r833  
    3636    /// \brief Class describing the concept of directed graphs.
    3737    ///
    38     /// This class describes the \ref concept "concept" of the
    39     /// immutable directed digraphs.
     38    /// This class describes the common interface of all directed
     39    /// graphs (digraphs).
    4040    ///
    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.
    4347    ///
    44     /// \sa concept
     48    /// \sa Graph
    4549    class Digraph {
    4650    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.
    5855      void operator=(const Digraph &) {}
     56
    5957    public:
    60       ///\e
    61 
    62       /// Defalult constructor.
    63 
    64       /// Defalult constructor.
    65       ///
     58      /// Default constructor.
    6659      Digraph() { }
    67       /// Class for identifying a node of the digraph
     60
     61      /// The node type of the digraph
    6862
    6963      /// This class identifies a node of the digraph. It also serves
    7064      /// as a base class of the node iterators,
    71       /// thus they will convert to this type.
     65      /// thus they convert to this type.
    7266      class Node {
    7367      public:
    7468        /// Default constructor
    7569
    76         /// @warning The default constructor sets the iterator
    77         /// to an undefined value.
     70        /// Default constructor.
     71        /// \warning It sets the object to an undefined value.
    7872        Node() { }
    7973        /// Copy constructor.
     
    8377        Node(const Node&) { }
    8478
    85         /// Invalid constructor \& conversion.
    86 
    87         /// This constructor initializes the iterator to be invalid.
     79        /// %Invalid constructor \& conversion.
     80
     81        /// Initializes the object to be invalid.
    8882        /// \sa Invalid for more details.
    8983        Node(Invalid) { }
    9084        /// Equality operator
    9185
     86        /// Equality operator.
     87        ///
    9288        /// 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.
    9490        bool operator==(Node) const { return true; }
    9591
    9692        /// Inequality operator
    9793
    98         /// \sa operator==(Node n)
    99         ///
     94        /// Inequality operator.
    10095        bool operator!=(Node) const { return true; }
    10196
    10297        /// Artificial ordering operator.
    10398
    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.
    110104        bool operator<(Node) const { return false; }
    111 
    112       };
    113 
    114       /// This iterator goes through each node.
    115 
    116       /// This iterator goes through each node.
    117       /// Its usage is quite simple, for example you can count the number
    118       /// of nodes in digraph \c g of type \c Digraph like this:
     105      };
     106
     107      /// Iterator class for the nodes.
     108
     109      /// This iterator goes through each node of the digraph.
     110      /// Its usage is quite simple, for example, you can count the number
     111      /// of nodes in a digraph \c g of type \c %Digraph like this:
    119112      ///\code
    120113      /// int count=0;
     
    125118        /// Default constructor
    126119
    127         /// @warning The default constructor sets the iterator
    128         /// to an undefined value.
     120        /// Default constructor.
     121        /// \warning It sets the iterator to an undefined value.
    129122        NodeIt() { }
    130123        /// Copy constructor.
     
    133126        ///
    134127        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.
    138131        /// \sa Invalid for more details.
    139132        NodeIt(Invalid) { }
    140133        /// Sets the iterator to the first node.
    141134
    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        ///
    151142        NodeIt(const Digraph&, const Node&) { }
    152143        /// Next node.
     
    158149
    159150
    160       /// Class for identifying an arc of the digraph
     151      /// The arc type of the digraph
    161152
    162153      /// This class identifies an arc of the digraph. It also serves
     
    167158        /// Default constructor
    168159
    169         /// @warning The default constructor sets the iterator
    170         /// to an undefined value.
     160        /// Default constructor.
     161        /// \warning It sets the object to an undefined value.
    171162        Arc() { }
    172163        /// Copy constructor.
     
    175166        ///
    176167        Arc(const Arc&) { }
    177         /// Initialize the iterator to be invalid.
    178 
    179         /// Initialize the iterator to be invalid.
    180         ///
     168        /// %Invalid constructor \& conversion.
     169
     170        /// Initializes the object to be invalid.
     171        /// \sa Invalid for more details.
    181172        Arc(Invalid) { }
    182173        /// Equality operator
    183174
     175        /// Equality operator.
     176        ///
    184177        /// 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.
    186179        bool operator==(Arc) const { return true; }
    187180        /// Inequality operator
    188181
    189         /// \sa operator==(Arc n)
    190         ///
     182        /// Inequality operator.
    191183        bool operator!=(Arc) const { return true; }
    192184
    193185        /// Artificial ordering operator.
    194186
    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.
    201192        bool operator<(Arc) const { return false; }
    202193      };
    203194
    204       /// This iterator goes trough the outgoing arcs of a node.
     195      /// Iterator class for the outgoing arcs of a node.
    205196
    206197      /// This iterator goes trough the \e outgoing arcs of a certain node
    207198      /// of a digraph.
    208       /// Its usage is quite simple, for example you can count the number
     199      /// Its usage is quite simple, for example, you can count the number
    209200      /// of outgoing arcs of a node \c n
    210       /// in digraph \c g of type \c Digraph as follows.
     201      /// in a digraph \c g of type \c %Digraph as follows.
    211202      ///\code
    212203      /// 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;
    214205      ///\endcode
    215 
    216206      class OutArcIt : public Arc {
    217207      public:
    218208        /// Default constructor
    219209
    220         /// @warning The default constructor sets the iterator
    221         /// to an undefined value.
     210        /// Default constructor.
     211        /// \warning It sets the iterator to an undefined value.
    222212        OutArcIt() { }
    223213        /// Copy constructor.
     
    226216        ///
    227217        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.
    232222        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 of
    236         /// 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        ///
    237227        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        ///
    243232        OutArcIt(const Digraph&, const Arc&) { }
    244         ///Next outgoing arc
     233        /// Next outgoing arc
    245234
    246235        /// Assign the iterator to the next
     
    249238      };
    250239
    251       /// This iterator goes trough the incoming arcs of a node.
     240      /// Iterator class for the incoming arcs of a node.
    252241
    253242      /// This iterator goes trough the \e incoming arcs of a certain node
    254243      /// of a digraph.
    255       /// Its usage is quite simple, for example you can count the number
    256       /// of outgoing arcs of a node \c n
    257       /// in digraph \c g of type \c Digraph as follows.
     244      /// Its usage is quite simple, for example, you can count the number
     245      /// of incoming arcs of a node \c n
     246      /// in a digraph \c g of type \c %Digraph as follows.
    258247      ///\code
    259248      /// 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;
    261250      ///\endcode
    262 
    263251      class InArcIt : public Arc {
    264252      public:
    265253        /// Default constructor
    266254
    267         /// @warning The default constructor sets the iterator
    268         /// to an undefined value.
     255        /// Default constructor.
     256        /// \warning It sets the iterator to an undefined value.
    269257        InArcIt() { }
    270258        /// Copy constructor.
     
    273261        ///
    274262        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.
    279267        InArcIt(Invalid) { }
    280         /// This constructor sets the iterator to first incoming arc.
    281 
    282         /// This constructor set the iterator to the first incoming arc of
    283         /// the node.
     268        /// Sets the iterator to the first incoming arc.
     269
     270        /// Sets the iterator to the first incoming arc of the given node.
     271        ///
    284272        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        ///
    290277        InArcIt(const Digraph&, const Arc&) { }
    291278        /// Next incoming arc
    292279
    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.
    295282        InArcIt& operator++() { return *this; }
    296283      };
    297       /// This iterator goes through each arc.
    298 
    299       /// This iterator goes through each arc of a digraph.
    300       /// 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:
     284
     285      /// Iterator class for the arcs.
     286
     287      /// This iterator goes through each arc of the digraph.
     288      /// Its usage is quite simple, for example, you can count the number
     289      /// of arcs in a digraph \c g of type \c %Digraph as follows:
    302290      ///\code
    303291      /// int count=0;
    304       /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
     292      /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
    305293      ///\endcode
    306294      class ArcIt : public Arc {
     
    308296        /// Default constructor
    309297
    310         /// @warning The default constructor sets the iterator
    311         /// to an undefined value.
     298        /// Default constructor.
     299        /// \warning It sets the iterator to an undefined value.
    312300        ArcIt() { }
    313301        /// Copy constructor.
     
    316304        ///
    317305        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.
    322310        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        ///
    333320        ArcIt(const Digraph&, const Arc&) { }
    334         ///Next arc
     321        /// Next arc
    335322
    336323        /// Assign the iterator to the next arc.
     324        ///
    337325        ArcIt& operator++() { return *this; }
    338326      };
    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.
    343336      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.
    351341      int id(Node) const { return -1; }
    352342
    353       /// \brief Returns the ID of the arc.
     343      /// \brief The ID of the arc.
     344      ///
     345      /// Returns the ID of the given arc.
    354346      int id(Arc) const { return -1; }
    355347
    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.
    359352      Node nodeFromId(int) const { return INVALID; }
    360353
    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.
    364358      Arc arcFromId(int) const { return INVALID; }
    365359
    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.
    367363      int maxNodeId() const { return -1; }
    368364
    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.
    370368      int maxArcId() const { return -1; }
    371369
     
    393391      int maxId(Arc) const { return -1; }
    394392
     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
    395398      /// \brief The base node of the iterator.
    396399      ///
    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; }
    400403
    401404      /// \brief The running node of the iterator.
    402405      ///
    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; }
    406409
    407410      /// \brief The base node of the iterator.
    408411      ///
    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; }
    412415
    413416      /// \brief The running node of the iterator.
    414417      ///
    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.
    427426      template<class T>
    428427      class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
    429428      public:
    430429
    431         ///\e
    432         NodeMap(const Digraph&) { }
    433         ///\e
     430        /// Constructor
     431        explicit NodeMap(const Digraph&) { }
     432        /// Constructor with given initial value
    434433        NodeMap(const Digraph&, T) { }
    435434
     
    446445      };
    447446
    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.
    451451      template<class T>
    452452      class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
    453453      public:
    454454
    455         ///\e
    456         ArcMap(const Digraph&) { }
    457         ///\e
     455        /// Constructor
     456        explicit ArcMap(const Digraph&) { }
     457        /// Constructor with given initial value
    458458        ArcMap(const Digraph&, T) { }
     459
    459460      private:
    460461        ///Copy constructor
  • lemon/concepts/graph.h

    r704 r833  
    1919///\ingroup graph_concepts
    2020///\file
    21 ///\brief The concept of Undirected Graphs.
     21///\brief The concept of undirected graphs.
    2222
    2323#ifndef LEMON_CONCEPTS_GRAPH_H
     
    2525
    2626#include <lemon/concepts/graph_components.h>
     27#include <lemon/concepts/maps.h>
     28#include <lemon/concept_check.h>
    2729#include <lemon/core.h>
    2830
     
    3234    /// \ingroup graph_concepts
    3335    ///
    34     /// \brief Class describing the concept of Undirected Graphs.
     36    /// \brief Class describing the concept of undirected graphs.
    3537    ///
    36     /// This class describes the common interface of all Undirected
    37     /// Graphs.
     38    /// This class describes the common interface of all undirected
     39    /// graphs.
    3840    ///
    39     /// As all concept describing classes it provides only interface
    40     /// without any sensible implementation. So any algorithm for
    41     /// undirected graph should compile with this class, but it will not
     41    /// 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
    4244    /// run properly, of course.
     45    /// An actual graph implementation like \ref ListGraph or
     46    /// \ref SmartGraph may have additional functionality.   
    4347    ///
    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.
    5361    ///
    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.
    6168    ///
    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
    6873    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
    6981    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
    7590      /// specializations for undirected graphs.
    7691      typedef True UndirectedTag;
    7792
    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.
    8598      class Node {
    8699      public:
    87100        /// Default constructor
    88101
    89         /// @warning The default constructor sets the iterator
    90         /// to an undefined value.
     102        /// Default constructor.
     103        /// \warning It sets the object to an undefined value.
    91104        Node() { }
    92105        /// Copy constructor.
     
    96109        Node(const Node&) { }
    97110
    98         /// Invalid constructor \& conversion.
    99 
    100         /// This constructor initializes the iterator to be invalid.
     111        /// %Invalid constructor \& conversion.
     112
     113        /// Initializes the object to be invalid.
    101114        /// \sa Invalid for more details.
    102115        Node(Invalid) { }
    103116        /// Equality operator
    104117
     118        /// Equality operator.
     119        ///
    105120        /// 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.
    107122        bool operator==(Node) const { return true; }
    108123
    109124        /// Inequality operator
    110125
    111         /// \sa operator==(Node n)
    112         ///
     126        /// Inequality operator.
    113127        bool operator!=(Node) const { return true; }
    114128
    115129        /// Artificial ordering operator.
    116130
    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
    121134        /// the items; this order has nothing to do with the iteration
    122135        /// ordering of the items.
     
    125138      };
    126139
    127       /// This iterator goes through each node.
    128 
    129       /// This iterator goes through each node.
    130       /// Its usage is quite simple, for example you can count the number
    131       /// of nodes in graph \c g of type \c Graph like this:
     140      /// Iterator class for the nodes.
     141
     142      /// This iterator goes through each node of the graph.
     143      /// Its usage is quite simple, for example, you can count the number
     144      /// of nodes in a graph \c g of type \c %Graph like this:
    132145      ///\code
    133146      /// int count=0;
     
    138151        /// Default constructor
    139152
    140         /// @warning The default constructor sets the iterator
    141         /// to an undefined value.
     153        /// Default constructor.
     154        /// \warning It sets the iterator to an undefined value.
    142155        NodeIt() { }
    143156        /// Copy constructor.
     
    146159        ///
    147160        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.
    151164        /// \sa Invalid for more details.
    152165        NodeIt(Invalid) { }
    153166        /// Sets the iterator to the first node.
    154167
    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        ///
    164175        NodeIt(const Graph&, const Node&) { }
    165176        /// Next node.
     
    171182
    172183
    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.
    177189      class Edge {
    178190      public:
    179191        /// Default constructor
    180192
    181         /// @warning The default constructor sets the iterator
    182         /// to an undefined value.
     193        /// Default constructor.
     194        /// \warning It sets the object to an undefined value.
    183195        Edge() { }
    184196        /// Copy constructor.
     
    187199        ///
    188200        Edge(const Edge&) { }
    189         /// Initialize the iterator to be invalid.
    190 
    191         /// Initialize the iterator to be invalid.
    192         ///
     201        /// %Invalid constructor \& conversion.
     202
     203        /// Initializes the object to be invalid.
     204        /// \sa Invalid for more details.
    193205        Edge(Invalid) { }
    194206        /// Equality operator
    195207
     208        /// Equality operator.
     209        ///
    196210        /// 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.
    198212        bool operator==(Edge) const { return true; }
    199213        /// Inequality operator
    200214
    201         /// \sa operator==(Edge n)
    202         ///
     215        /// Inequality operator.
    203216        bool operator!=(Edge) const { return true; }
    204217
    205218        /// Artificial ordering operator.
    206219
    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.
    213225        bool operator<(Edge) const { return false; }
    214226      };
    215227
    216       /// This iterator goes through each edge.
    217 
    218       /// This iterator goes through each edge of a graph.
    219       /// 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:
     228      /// Iterator class for the edges.
     229
     230      /// This iterator goes through each edge of the graph.
     231      /// Its usage is quite simple, for example, you can count the number
     232      /// of edges in a graph \c g of type \c %Graph as follows:
    221233      ///\code
    222234      /// int count=0;
     
    227239        /// Default constructor
    228240
    229         /// @warning The default constructor sets the iterator
    230         /// to an undefined value.
     241        /// Default constructor.
     242        /// \warning It sets the iterator to an undefined value.
    231243        EdgeIt() { }
    232244        /// Copy constructor.
     
    235247        ///
    236248        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.
    241253        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        ///
    252263        EdgeIt(const Graph&, const Edge&) { }
    253264        /// Next edge
    254265
    255266        /// Assign the iterator to the next edge.
     267        ///
    256268        EdgeIt& operator++() { return *this; }
    257269      };
    258270
    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       ///
    266       /// Its usage is quite simple, for example you can compute the
    267       /// degree (i.e. count the number of incident arcs of a node \c n
    268       /// in graph \c g of type \c Graph as follows.
     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.
     275      /// Its usage is quite simple, for example, you can compute the
     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.
    269278      ///
    270279      ///\code
     
    272281      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    273282      ///\endcode
     283      ///
     284      /// \warning Loop edges will be iterated twice.
    274285      class IncEdgeIt : public Edge {
    275286      public:
    276287        /// Default constructor
    277288
    278         /// @warning The default constructor sets the iterator
    279         /// to an undefined value.
     289        /// Default constructor.
     290        /// \warning It sets the iterator to an undefined value.
    280291        IncEdgeIt() { }
    281292        /// Copy constructor.
     
    284295        ///
    285296        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.
    290301        IncEdgeIt(Invalid) { }
    291         /// This constructor sets the iterator to first incident arc.
    292 
    293         /// This constructor set the iterator to the first incident arc of
    294         /// the node.
     302        /// Sets the iterator to the first incident edge.
     303
     304        /// Sets the iterator to the first incident edge of the given node.
     305        ///
    295306        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        ///
    301311        IncEdgeIt(const Graph&, const Edge&) { }
    302         /// Next incident arc
    303 
    304         /// Assign the iterator to the next incident arc
     312        /// Next incident edge
     313
     314        /// Assign the iterator to the next incident edge
    305315        /// of the corresponding node.
    306316        IncEdgeIt& operator++() { return *this; }
    307317      };
    308318
    309       /// The directed arc type.
    310 
    311       /// The directed arc type. It can be converted to the
    312       /// edge or it should be inherited from the undirected
    313       /// edge.
     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.
    314324      class Arc {
    315325      public:
    316326        /// Default constructor
    317327
    318         /// @warning The default constructor sets the iterator
    319         /// to an undefined value.
     328        /// Default constructor.
     329        /// \warning It sets the object to an undefined value.
    320330        Arc() { }
    321331        /// Copy constructor.
     
    324334        ///
    325335        Arc(const Arc&) { }
    326         /// Initialize the iterator to be invalid.
    327 
    328         /// Initialize the iterator to be invalid.
    329         ///
     336        /// %Invalid constructor \& conversion.
     337
     338        /// Initializes the object to be invalid.
     339        /// \sa Invalid for more details.
    330340        Arc(Invalid) { }
    331341        /// Equality operator
    332342
     343        /// Equality operator.
     344        ///
    333345        /// 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.
    335347        bool operator==(Arc) const { return true; }
    336348        /// Inequality operator
    337349
    338         /// \sa operator==(Arc n)
    339         ///
     350        /// Inequality operator.
    340351        bool operator!=(Arc) const { return true; }
    341352
    342353        /// Artificial ordering operator.
    343354
    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.
    350360        bool operator<(Arc) const { return false; }
    351361
    352         /// Converison to Edge
     362        /// Converison to \c Edge
     363       
     364        /// Converison to \c Edge.
     365        ///
    353366        operator Edge() const { return Edge(); }
    354367      };
    355       /// This iterator goes through each directed arc.
    356 
    357       /// This iterator goes through each arc of a graph.
    358       /// 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:
     368
     369      /// Iterator class for the arcs.
     370
     371      /// This iterator goes through each directed arc of the graph.
     372      /// Its usage is quite simple, for example, you can count the number
     373      /// of arcs in a graph \c g of type \c %Graph as follows:
    360374      ///\code
    361375      /// int count=0;
    362       /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
     376      /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
    363377      ///\endcode
    364378      class ArcIt : public Arc {
     
    366380        /// Default constructor
    367381
    368         /// @warning The default constructor sets the iterator
    369         /// to an undefined value.
     382        /// Default constructor.
     383        /// \warning It sets the iterator to an undefined value.
    370384        ArcIt() { }
    371385        /// Copy constructor.
     
    374388        ///
    375389        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.
    380394        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        ///
    391404        ArcIt(const Graph&, const Arc&) { }
    392         ///Next arc
     405        /// Next arc
    393406
    394407        /// Assign the iterator to the next arc.
     408        ///
    395409        ArcIt& operator++() { return *this; }
    396410      };
    397411
    398       /// This iterator goes trough the outgoing directed arcs of a node.
    399 
    400       /// This iterator goes trough the \e outgoing arcs of a certain node
    401       /// of a graph.
    402       /// Its usage is quite simple, for example you can count the number
     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.
     416      /// Its usage is quite simple, for example, you can count the number
    403417      /// of outgoing arcs of a node \c n
    404       /// in graph \c g of type \c Graph as follows.
     418      /// in a graph \c g of type \c %Graph as follows.
    405419      ///\code
    406420      /// 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;
    408422      ///\endcode
    409 
    410423      class OutArcIt : public Arc {
    411424      public:
    412425        /// Default constructor
    413426
    414         /// @warning The default constructor sets the iterator
    415         /// to an undefined value.
     427        /// Default constructor.
     428        /// \warning It sets the iterator to an undefined value.
    416429        OutArcIt() { }
    417430        /// Copy constructor.
     
    420433        ///
    421434        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.
    426439        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        ///
    433444        OutArcIt(const Graph& n, const Node& g) {
    434445          ignore_unused_variable_warning(n);
    435446          ignore_unused_variable_warning(g);
    436447        }
    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        ///
    442452        OutArcIt(const Graph&, const Arc&) { }
    443         ///Next outgoing arc
     453        /// Next outgoing arc
    444454
    445455        /// Assign the iterator to the next
     
    448458      };
    449459
    450       /// This iterator goes trough the incoming directed arcs of a node.
    451 
    452       /// This iterator goes trough the \e incoming arcs of a certain node
    453       /// of a graph.
    454       /// Its usage is quite simple, for example you can count the number
    455       /// of outgoing arcs of a node \c n
    456       /// in graph \c g of type \c Graph as follows.
     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.
     464      /// Its usage is quite simple, for example, you can count the number
     465      /// of incoming arcs of a node \c n
     466      /// in a graph \c g of type \c %Graph as follows.
    457467      ///\code
    458468      /// 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;
    460470      ///\endcode
    461 
    462471      class InArcIt : public Arc {
    463472      public:
    464473        /// Default constructor
    465474
    466         /// @warning The default constructor sets the iterator
    467         /// to an undefined value.
     475        /// Default constructor.
     476        /// \warning It sets the iterator to an undefined value.
    468477        InArcIt() { }
    469478        /// Copy constructor.
     
    472481        ///
    473482        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.
    478487        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        ///
    485492        InArcIt(const Graph& g, const Node& n) {
    486493          ignore_unused_variable_warning(n);
    487494          ignore_unused_variable_warning(g);
    488495        }
    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        ///
    494500        InArcIt(const Graph&, const Arc&) { }
    495501        /// Next incoming arc
    496502
    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.
    499505        InArcIt& operator++() { return *this; }
    500506      };
    501507
    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.
    505512      template<class T>
    506513      class NodeMap : public ReferenceMap<Node, T, T&, const T&>
     
    508515      public:
    509516
    510         ///\e
    511         NodeMap(const Graph&) { }
    512         ///\e
     517        /// Constructor
     518        explicit NodeMap(const Graph&) { }
     519        /// Constructor with given initial value
    513520        NodeMap(const Graph&, T) { }
    514521
     
    525532      };
    526533
    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.
    530538      template<class T>
    531539      class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
     
    533541      public:
    534542
    535         ///\e
    536         ArcMap(const Graph&) { }
    537         ///\e
     543        /// Constructor
     544        explicit ArcMap(const Graph&) { }
     545        /// Constructor with given initial value
    538546        ArcMap(const Graph&, T) { }
     547
    539548      private:
    540549        ///Copy constructor
     
    549558      };
    550559
    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.
    554564      template<class T>
    555565      class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
     
    557567      public:
    558568
    559         ///\e
    560         EdgeMap(const Graph&) { }
    561         ///\e
     569        /// Constructor
     570        explicit EdgeMap(const Graph&) { }
     571        /// Constructor with given initial value
    562572        EdgeMap(const Graph&, T) { }
     573
    563574      private:
    564575        ///Copy constructor
     
    573584      };
    574585
    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.
    619595      /// \sa v()
    620596      /// \sa direction()
    621597      Node u(Edge) const { return INVALID; }
    622598
    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.
    633608      /// \sa u()
    634609      /// \sa direction()
    635610      Node v(Edge) const { return INVALID; }
    636611
    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.
    638615      Node source(Arc) const { return INVALID; }
    639616
    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.
    641620      Node target(Arc) const { return INVALID; }
    642621
    643       /// \brief Returns the id of the node.
     622      /// \brief The ID of the node.
     623      ///
     624      /// Returns the ID of the given node.
    644625      int id(Node) const { return -1; }
    645626
    646       /// \brief Returns the id of the edge.
     627      /// \brief The ID of the edge.
     628      ///
     629      /// Returns the ID of the given edge.
    647630      int id(Edge) const { return -1; }
    648631
    649       /// \brief Returns the id of the arc.
     632      /// \brief The ID of the arc.
     633      ///
     634      /// Returns the ID of the given arc.
    650635      int id(Arc) const { return -1; }
    651636
    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.
    655641      Node nodeFromId(int) const { return INVALID; }
    656642
    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.
    660647      Edge edgeFromId(int) const { return INVALID; }
    661648
    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.
    665653      Arc arcFromId(int) const { return INVALID; }
    666654
    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.
    668658      int maxNodeId() const { return -1; }
    669659
    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.
    671663      int maxEdgeId() const { return -1; }
    672664
    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.
    674668      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; }
    675703
    676704      void first(Node&) const {}
     
    706734      int maxId(Arc) const { return -1; }
    707735
    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; }
    749769
    750770      template <typename _Graph>
  • lemon/concepts/graph_components.h

    r713 r833  
    1919///\ingroup graph_concepts
    2020///\file
    21 ///\brief The concept of graph components.
     21///\brief The concepts of graph components.
    2222
    2323#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
     
    9393      /// associative containers (e.g. \c std::map).
    9494      ///
    95       /// \note This operator only have to define some strict ordering of
     95      /// \note This operator only has to define some strict ordering of
    9696      /// the items; this order has nothing to do with the iteration
    9797      /// ordering of the items.
  • lemon/concepts/heap.h

    r757 r883  
    8989      /// handle the cross references. The assigned value must be
    9090      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
     91#ifdef DOXYGEN
    9192      explicit Heap(ItemIntMap &map) {}
     93#else
     94      explicit Heap(ItemIntMap&) {}
     95#endif     
    9296
    9397      /// \brief Constructor.
     
    99103      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
    100104      /// \param comp The function object used for comparing the priorities.
     105#ifdef DOXYGEN
    101106      explicit Heap(ItemIntMap &map, const CMP &comp) {}
     107#else
     108      explicit Heap(ItemIntMap&, const CMP&) {}
     109#endif     
    102110
    103111      /// \brief The number of items stored in the heap.
     
    127135      /// \param p The priority of the item.
    128136      /// \pre \e i must not be stored in the heap.
     137#ifdef DOXYGEN
    129138      void push(const Item &i, const Prio &p) {}
     139#else
     140      void push(const Item&, const Prio&) {}
     141#endif     
    130142
    131143      /// \brief Return the item having minimum priority.
     
    133145      /// This function returns the item having minimum priority.
    134146      /// \pre The heap must be non-empty.
    135       Item top() const {}
     147      Item top() const { return Item(); }
    136148
    137149      /// \brief The minimum priority.
     
    139151      /// This function returns the minimum priority.
    140152      /// \pre The heap must be non-empty.
    141       Prio prio() const {}
     153      Prio prio() const { return Prio(); }
    142154
    143155      /// \brief Remove the item having minimum priority.
     
    153165      /// \param i The item to delete.
    154166      /// \pre \e i must be in the heap.
     167#ifdef DOXYGEN
    155168      void erase(const Item &i) {}
     169#else
     170      void erase(const Item&) {}
     171#endif     
    156172
    157173      /// \brief The priority of the given item.
     
    160176      /// \param i The item.
    161177      /// \pre \e i must be in the heap.
     178#ifdef DOXYGEN
    162179      Prio operator[](const Item &i) const {}
     180#else
     181      Prio operator[](const Item&) const { return Prio(); }
     182#endif     
    163183
    164184      /// \brief Set the priority of an item or insert it, if it is
     
    171191      /// \param i The item.
    172192      /// \param p The priority.
     193#ifdef DOXYGEN
    173194      void set(const Item &i, const Prio &p) {}
     195#else
     196      void set(const Item&, const Prio&) {}
     197#endif     
    174198
    175199      /// \brief Decrease the priority of an item to the given value.
     
    179203      /// \param p The priority.
    180204      /// \pre \e i must be stored in the heap with priority at least \e p.
     205#ifdef DOXYGEN
    181206      void decrease(const Item &i, const Prio &p) {}
     207#else
     208      void decrease(const Item&, const Prio&) {}
     209#endif     
    182210
    183211      /// \brief Increase the priority of an item to the given value.
     
    187215      /// \param p The priority.
    188216      /// \pre \e i must be stored in the heap with priority at most \e p.
     217#ifdef DOXYGEN
    189218      void increase(const Item &i, const Prio &p) {}
     219#else
     220      void increase(const Item&, const Prio&) {}
     221#endif     
    190222
    191223      /// \brief Return the state of an item.
     
    197229      /// to the heap again.
    198230      /// \param i The item.
     231#ifdef DOXYGEN
    199232      State state(const Item &i) const {}
     233#else
     234      State state(const Item&) const { return PRE_HEAP; }
     235#endif     
    200236
    201237      /// \brief Set the state of an item in the heap.
     
    206242      /// \param i The item.
    207243      /// \param st The state. It should not be \c IN_HEAP.
     244#ifdef DOXYGEN
    208245      void state(const Item& i, State st) {}
     246#else
     247      void state(const Item&, State) {}
     248#endif     
    209249
    210250
  • lemon/concepts/maps.h

    r576 r765  
    183183      template<typename _ReferenceMap>
    184184      struct Constraints {
    185         void constraints() {
     185        typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type
     186        constraints() {
    186187          checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
    187188          ref = m[key];
  • lemon/concepts/path.h

    r606 r832  
    1919///\ingroup concept
    2020///\file
    21 ///\brief Classes for representing paths in digraphs.
     21///\brief The concept of paths
    2222///
    2323
     
    3939    /// A skeleton structure for representing directed paths in a
    4040    /// digraph.
     41    /// In a sense, a path can be treated as a list of arcs.
     42    /// LEMON path types just store this list. As a consequence, they cannot
     43    /// enumerate the nodes on the path directly and a zero length path
     44    /// cannot store its source node.
     45    ///
     46    /// The arcs of a path should be stored in the order of their directions,
     47    /// i.e. the target node of each arc should be the same as the source
     48    /// node of the next arc. This consistency could be checked using
     49    /// \ref checkPath().
     50    /// The source and target nodes of a (consistent) path can be obtained
     51    /// using \ref pathSource() and \ref pathTarget().
     52    ///
     53    /// A path can be constructed from another path of any type using the
     54    /// copy constructor or the assignment operator.
     55    ///
    4156    /// \tparam GR The digraph type in which the path is.
    42     ///
    43     /// In a sense, the path can be treated as a list of arcs. The
    44     /// lemon path type stores just this list. As a consequence it
    45     /// cannot enumerate the nodes in the path and the zero length
    46     /// paths cannot store the source.
    47     ///
    4857    template <typename GR>
    4958    class Path {
     
    6069      Path() {}
    6170
    62       /// \brief Template constructor
     71      /// \brief Template copy constructor
    6372      template <typename CPath>
    6473      Path(const CPath& cpath) {}
    6574
    66       /// \brief Template assigment
     75      /// \brief Template assigment operator
    6776      template <typename CPath>
    6877      Path& operator=(const CPath& cpath) {
     
    7180      }
    7281
    73       /// Length of the path ie. the number of arcs in the path.
     82      /// Length of the path, i.e. the number of arcs on the path.
    7483      int length() const { return 0;}
    7584
     
    8089      void clear() {}
    8190
    82       /// \brief LEMON style iterator for path arcs
     91      /// \brief LEMON style iterator for enumerating the arcs of a path.
    8392      ///
    84       /// This class is used to iterate on the arcs of the paths.
     93      /// LEMON style iterator class for enumerating the arcs of a path.
    8594      class ArcIt {
    8695      public:
     
    8998        /// Invalid constructor
    9099        ArcIt(Invalid) {}
    91         /// Constructor for first arc
     100        /// Sets the iterator to the first arc of the given path
    92101        ArcIt(const Path &) {}
    93102
    94         /// Conversion to Arc
     103        /// Conversion to \c Arc
    95104        operator Arc() const { return INVALID; }
    96105
     
    193202    ///
    194203    /// A skeleton structure for path dumpers. The path dumpers are
    195     /// the generalization of the paths. The path dumpers can
    196     /// enumerate the arcs of the path wheter in forward or in
    197     /// backward order.  In most time these classes are not used
    198     /// directly rather it used to assign a dumped class to a real
    199     /// path type.
     204    /// the generalization of the paths, they can enumerate the arcs
     205    /// of the path either in forward or in backward order.
     206    /// These classes are typically not used directly, they are rather
     207    /// used to be assigned to a real path type.
    200208    ///
    201209    /// The main purpose of this concept is that the shortest path
    202     /// algorithms can enumerate easily the arcs in reverse order.
    203     /// If we would like to give back a real path from these
    204     /// algorithms then we should create a temporarly path object. In
    205     /// LEMON such algorithms gives back a path dumper what can
    206     /// assigned to a real path and the dumpers can be implemented as
     210    /// algorithms can enumerate the arcs easily in reverse order.
     211    /// In LEMON, such algorithms give back a (reverse) path dumper that
     212    /// can be assigned to a real path. The dumpers can be implemented as
    207213    /// an adaptor class to the predecessor map.
    208214    ///
    209215    /// \tparam GR The digraph type in which the path is.
    210     ///
    211     /// The paths can be constructed from any path type by a
    212     /// template constructor or a template assignment operator.
    213216    template <typename GR>
    214217    class PathDumper {
     
    220223      typedef typename Digraph::Arc Arc;
    221224
    222       /// Length of the path ie. the number of arcs in the path.
     225      /// Length of the path, i.e. the number of arcs on the path.
    223226      int length() const { return 0;}
    224227
     
    228231      /// \brief Forward or reverse dumping
    229232      ///
    230       /// If the RevPathTag is defined and true then reverse dumping
    231       /// is provided in the path dumper. In this case instead of the
    232       /// ArcIt the RevArcIt iterator should be implemented in the
    233       /// dumper.
     233      /// If this tag is defined to be \c True, then reverse dumping
     234      /// is provided in the path dumper. In this case, \c RevArcIt
     235      /// iterator should be implemented instead of \c ArcIt iterator.
    234236      typedef False RevPathTag;
    235237
    236       /// \brief LEMON style iterator for path arcs
     238      /// \brief LEMON style iterator for enumerating the arcs of a path.
    237239      ///
    238       /// This class is used to iterate on the arcs of the paths.
     240      /// LEMON style iterator class for enumerating the arcs of a path.
    239241      class ArcIt {
    240242      public:
     
    243245        /// Invalid constructor
    244246        ArcIt(Invalid) {}
    245         /// Constructor for first arc
     247        /// Sets the iterator to the first arc of the given path
    246248        ArcIt(const PathDumper&) {}
    247249
    248         /// Conversion to Arc
     250        /// Conversion to \c Arc
    249251        operator Arc() const { return INVALID; }
    250252
     
    261263      };
    262264
    263       /// \brief LEMON style iterator for path arcs
     265      /// \brief LEMON style iterator for enumerating the arcs of a path
     266      /// in reverse direction.
    264267      ///
    265       /// This class is used to iterate on the arcs of the paths in
    266       /// reverse direction.
     268      /// LEMON style iterator class for enumerating the arcs of a path
     269      /// in reverse direction.
    267270      class RevArcIt {
    268271      public:
     
    271274        /// Invalid constructor
    272275        RevArcIt(Invalid) {}
    273         /// Constructor for first arc
     276        /// Sets the iterator to the last arc of the given path
    274277        RevArcIt(const PathDumper &) {}
    275278
    276         /// Conversion to Arc
     279        /// Conversion to \c Arc
    277280        operator Arc() const { return INVALID; }
    278281
  • lemon/counter.h

    r463 r833  
    213213  /// 'Do nothing' version of Counter.
    214214
    215   /// This class can be used in the same way as \ref Counter however it
     215  /// This class can be used in the same way as \ref Counter, but it
    216216  /// does not count at all and does not print report on destruction.
    217217  ///
  • lemon/cplex.cc

    r623 r793  
    112112  }
    113113
     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  }
    114147
    115148  void CplexBase::_eraseCol(int i) {
  • lemon/cplex.h

    r623 r793  
    9494    virtual int _addCol();
    9595    virtual int _addRow();
     96    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    9697
    9798    virtual void _eraseCol(int i);
  • lemon/dfs.h

    r631 r891  
    4848    ///The type of the map that stores the predecessor
    4949    ///arcs of the %DFS paths.
    50     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     50    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    5252    ///Instantiates a \c PredMap.
     
    6363
    6464    ///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.
    6667    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6768    ///Instantiates a \c ProcessedMap.
     
    8283
    8384    ///The type of the map that indicates which nodes are reached.
    84     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     85    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8586    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    8687    ///Instantiates a \c ReachedMap.
     
    9798
    9899    ///The type of the map that stores the distances of the nodes.
    99     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     100    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    100101    typedef typename Digraph::template NodeMap<int> DistMap;
    101102    ///Instantiates a \c DistMap.
     
    121122  ///\tparam GR The type of the digraph the algorithm runs on.
    122123  ///The default type is \ref ListDigraph.
     124  ///\tparam TR The traits class that defines various types used by the
     125  ///algorithm. By default, it is \ref DfsDefaultTraits
     126  ///"DfsDefaultTraits<GR>".
     127  ///In most cases, this parameter should not be set directly,
     128  ///consider to use the named template parameters instead.
    123129#ifdef DOXYGEN
    124130  template <typename GR,
     
    225231    ///\ref named-templ-param "Named parameter" for setting
    226232    ///\c PredMap type.
    227     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     233    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    228234    template <class T>
    229235    struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
     
    245251    ///\ref named-templ-param "Named parameter" for setting
    246252    ///\c DistMap type.
    247     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     253    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    248254    template <class T>
    249255    struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
     
    265271    ///\ref named-templ-param "Named parameter" for setting
    266272    ///\c ReachedMap type.
    267     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     273    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    268274    template <class T>
    269275    struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
     
    285291    ///\ref named-templ-param "Named parameter" for setting
    286292    ///\c ProcessedMap type.
    287     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     293    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    288294    template <class T>
    289295    struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
     
    412418    ///The simplest way to execute the DFS algorithm is to use one of the
    413419    ///member functions called \ref run(Node) "run()".\n
    414     ///If you need more control on the execution, first you have to call
    415     ///\ref init(), then you can add a source node with \ref addSource()
     420    ///If you need better control on the execution, you have to call
     421    ///\ref init() first, then you can add a source node with \ref addSource()
    416422    ///and perform the actual computation with \ref start().
    417423    ///This procedure can be repeated if there are nodes that have not
     
    633639    ///Runs the algorithm to visit all nodes in the digraph.
    634640
    635     ///This method runs the %DFS algorithm in order to compute the
    636     ///%DFS path to each node.
    637     ///
    638     ///The algorithm computes
    639     ///- the %DFS tree (forest),
    640     ///- the distance of each node from the root(s) in the %DFS tree.
     641    ///This method runs the %DFS algorithm in order to visit all nodes
     642    ///in the digraph.
    641643    ///
    642644    ///\note <tt>d.run()</tt> is just a shortcut of the following code.
     
    670672    ///@{
    671673
    672     ///The DFS path to a node.
    673 
    674     ///Returns the DFS path to a node.
     674    ///The DFS path to the given node.
     675
     676    ///Returns the DFS path to the given node from the root(s).
    675677    ///
    676678    ///\warning \c t should be reached from the root(s).
     
    680682    Path path(Node t) const { return Path(*G, *_pred, t); }
    681683
    682     ///The distance of a node from the root(s).
    683 
    684     ///Returns the distance of a node from the root(s).
     684    ///The distance of the given node from the root(s).
     685
     686    ///Returns the distance of the given node from the root(s).
    685687    ///
    686688    ///\warning If node \c v is not reached from the root(s), then
     
    691693    int dist(Node v) const { return (*_dist)[v]; }
    692694
    693     ///Returns the 'previous arc' of the %DFS tree for a node.
     695    ///Returns the 'previous arc' of the %DFS tree for the given node.
    694696
    695697    ///This function returns the 'previous arc' of the %DFS tree for the
     
    699701    ///
    700702    ///The %DFS tree used here is equal to the %DFS tree used in
    701     ///\ref predNode().
     703    ///\ref predNode() and \ref predMap().
    702704    ///
    703705    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    705707    Arc predArc(Node v) const { return (*_pred)[v];}
    706708
    707     ///Returns the 'previous node' of the %DFS tree.
     709    ///Returns the 'previous node' of the %DFS tree for the given node.
    708710
    709711    ///This function returns the 'previous node' of the %DFS
    710712    ///tree for the node \c v, i.e. it returns the last but one node
    711     ///from a %DFS path from a root to \c v. It is \c INVALID
     713    ///of a %DFS path from a root to \c v. It is \c INVALID
    712714    ///if \c v is not reached from the root(s) or if \c v is a root.
    713715    ///
    714716    ///The %DFS tree used here is equal to the %DFS tree used in
    715     ///\ref predArc().
     717    ///\ref predArc() and \ref predMap().
    716718    ///
    717719    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    734736    ///
    735737    ///Returns a const reference to the node map that stores the predecessor
    736     ///arcs, which form the DFS tree.
     738    ///arcs, which form the DFS tree (forest).
    737739    ///
    738740    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    740742    const PredMap &predMap() const { return *_pred;}
    741743
    742     ///Checks if a node is reached from the root(s).
     744    ///Checks if the given node. node is reached from the root(s).
    743745
    744746    ///Returns \c true if \c v is reached from the root(s).
     
    766768    ///The type of the map that stores the predecessor
    767769    ///arcs of the %DFS paths.
    768     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     770    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    769771    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    770772    ///Instantiates a PredMap.
     
    781783
    782784    ///The type of the map that indicates which nodes are processed.
    783     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    784     ///By default it is a NullMap.
     785    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     786    ///By default, it is a NullMap.
    785787    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    786788    ///Instantiates a ProcessedMap.
     
    801803
    802804    ///The type of the map that indicates which nodes are reached.
    803     ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     805    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    804806    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    805807    ///Instantiates a ReachedMap.
     
    816818
    817819    ///The type of the map that stores the distances of the nodes.
    818     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     820    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    819821    typedef typename Digraph::template NodeMap<int> DistMap;
    820822    ///Instantiates a DistMap.
     
    831833
    832834    ///The type of the DFS paths.
    833     ///It must meet the \ref concepts::Path "Path" concept.
     835    ///It must conform to the \ref concepts::Path "Path" concept.
    834836    typedef lemon::Path<Digraph> Path;
    835837  };
     
    837839  /// Default traits class used by DfsWizard
    838840
    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.
     841  /// Default traits class used by DfsWizard.
     842  /// \tparam GR The type of the digraph.
    845843  template<class GR>
    846844  class DfsWizardBase : public DfsWizardDefaultTraits<GR>
     
    870868    /// Constructor.
    871869
    872     /// This constructor does not require parameters, therefore it initiates
     870    /// This constructor does not require parameters, it initiates
    873871    /// all of the attributes to \c 0.
    874872    DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
     
    895893  /// This class should only be used through the \ref dfs() function,
    896894  /// which makes it easier to use the algorithm.
     895  ///
     896  /// \tparam TR The traits class that defines various types used by the
     897  /// algorithm.
    897898  template<class TR>
    898899  class DfsWizard : public TR
     
    900901    typedef TR Base;
    901902
    902     ///The type of the digraph the algorithm runs on.
    903903    typedef typename TR::Digraph Digraph;
    904904
     
    908908    typedef typename Digraph::OutArcIt OutArcIt;
    909909
    910     ///\brief The type of the map that stores the predecessor
    911     ///arcs of the DFS paths.
    912910    typedef typename TR::PredMap PredMap;
    913     ///\brief The type of the map that stores the distances of the nodes.
    914911    typedef typename TR::DistMap DistMap;
    915     ///\brief The type of the map that indicates which nodes are reached.
    916912    typedef typename TR::ReachedMap ReachedMap;
    917     ///\brief The type of the map that indicates which nodes are processed.
    918913    typedef typename TR::ProcessedMap ProcessedMap;
    919     ///The type of the DFS paths
    920914    typedef typename TR::Path Path;
    921915
     
    987981    ///Runs DFS algorithm to visit all nodes in the digraph.
    988982
    989     ///This method runs DFS algorithm in order to compute
    990     ///the DFS path to each node.
     983    ///This method runs DFS algorithm in order to visit all nodes
     984    ///in the digraph.
    991985    void run()
    992986    {
     
    1000994      SetPredMapBase(const TR &b) : TR(b) {}
    1001995    };
    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.
     996
     997    ///\brief \ref named-templ-param "Named parameter" for setting
     998    ///the predecessor map.
     999    ///
     1000    ///\ref named-templ-param "Named parameter" function for setting
     1001    ///the map that stores the predecessor arcs of the nodes.
    10071002    template<class T>
    10081003    DfsWizard<SetPredMapBase<T> > predMap(const T &t)
     
    10181013      SetReachedMapBase(const TR &b) : TR(b) {}
    10191014    };
    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.
     1015
     1016    ///\brief \ref named-templ-param "Named parameter" for setting
     1017    ///the reached map.
     1018    ///
     1019    ///\ref named-templ-param "Named parameter" function for setting
     1020    ///the map that indicates which nodes are reached.
    10251021    template<class T>
    10261022    DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
     
    10361032      SetDistMapBase(const TR &b) : TR(b) {}
    10371033    };
    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.
     1034
     1035    ///\brief \ref named-templ-param "Named parameter" for setting
     1036    ///the distance map.
     1037    ///
     1038    ///\ref named-templ-param "Named parameter" function for setting
     1039    ///the map that stores the distances of the nodes calculated
     1040    ///by the algorithm.
    10431041    template<class T>
    10441042    DfsWizard<SetDistMapBase<T> > distMap(const T &t)
     
    10541052      SetProcessedMapBase(const TR &b) : TR(b) {}
    10551053    };
    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.
     1054
     1055    ///\brief \ref named-func-param "Named parameter" for setting
     1056    ///the processed map.
     1057    ///
     1058    ///\ref named-templ-param "Named parameter" function for setting
     1059    ///the map that indicates which nodes are processed.
    10611060    template<class T>
    10621061    DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     
    12091208    ///
    12101209    /// The type of the map that indicates which nodes are reached.
    1211     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     1210    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    12121211    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    12131212
     
    12471246  /// does not observe the DFS events. If you want to observe the DFS
    12481247  /// events, you should implement your own visitor class.
    1249   /// \tparam TR Traits class to set various data types used by the
    1250   /// algorithm. The default traits class is
    1251   /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
    1252   /// See \ref DfsVisitDefaultTraits for the documentation of
    1253   /// a DFS visit traits class.
     1248  /// \tparam TR The traits class that defines various types used by the
     1249  /// algorithm. By default, it is \ref DfsVisitDefaultTraits
     1250  /// "DfsVisitDefaultTraits<GR>".
     1251  /// In most cases, this parameter should not be set directly,
     1252  /// consider to use the named template parameters instead.
    12541253#ifdef DOXYGEN
    12551254  template <typename GR, typename VS, typename TR>
     
    13701369    /// The simplest way to execute the DFS algorithm is to use one of the
    13711370    /// member functions called \ref run(Node) "run()".\n
    1372     /// If you need more control on the execution, first you have to call
    1373     /// \ref init(), then you can add a source node with \ref addSource()
     1371    /// If you need better control on the execution, you have to call
     1372    /// \ref init() first, then you can add a source node with \ref addSource()
    13741373    /// and perform the actual computation with \ref start().
    13751374    /// This procedure can be repeated if there are nodes that have not
     
    15841583    /// \brief Runs the algorithm to visit all nodes in the digraph.
    15851584
    1586     /// This method runs the %DFS algorithm in order to
    1587     /// compute the %DFS path to each node.
    1588     ///
    1589     /// The algorithm computes
    1590     /// - the %DFS tree (forest),
    1591     /// - the distance of each node from the root(s) in the %DFS tree.
     1585    /// This method runs the %DFS algorithm in order to visit all nodes
     1586    /// in the digraph.
    15921587    ///
    15931588    /// \note <tt>d.run()</tt> is just a shortcut of the following code.
     
    16211616    ///@{
    16221617
    1623     /// \brief Checks if a node is reached from the root(s).
     1618    /// \brief Checks if the given node is reached from the root(s).
    16241619    ///
    16251620    /// Returns \c true if \c v is reached from the root(s).
  • lemon/dijkstra.h

    r631 r891  
    7171
    7272    ///The type of the map that stores the arc lengths.
    73     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     73    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
    7474    typedef LEN LengthMap;
    75     ///The type of the length of the arcs.
     75    ///The type of the arc lengths.
    7676    typedef typename LEN::Value Value;
    7777
     
    117117    ///The type of the map that stores the predecessor
    118118    ///arcs of the shortest paths.
    119     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     119    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    120120    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    121121    ///Instantiates a \c PredMap.
     
    132132
    133133    ///The type of the map that indicates which nodes are processed.
    134     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    135     ///By default it is a NullMap.
     134    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     135    ///By default, it is a NullMap.
    136136    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    137137    ///Instantiates a \c ProcessedMap.
     
    152152
    153153    ///The type of the map that stores the distances of the nodes.
    154     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     154    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    155155    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
    156156    ///Instantiates a \c DistMap.
     
    169169  /// \ingroup shortest_path
    170170  ///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.
    171175  ///
    172176  ///The arc lengths are passed to the algorithm using a
     
    189193  ///it is necessary. The default map type is \ref
    190194  ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
     195  ///\tparam TR The traits class that defines various types used by the
     196  ///algorithm. By default, it is \ref DijkstraDefaultTraits
     197  ///"DijkstraDefaultTraits<GR, LEN>".
     198  ///In most cases, this parameter should not be set directly,
     199  ///consider to use the named template parameters instead.
    191200#ifdef DOXYGEN
    192201  template <typename GR, typename LEN, typename TR>
     
    202211    typedef typename TR::Digraph Digraph;
    203212
    204     ///The type of the length of the arcs.
    205     typedef typename TR::LengthMap::Value Value;
     213    ///The type of the arc lengths.
     214    typedef typename TR::Value Value;
    206215    ///The type of the map that stores the arc lengths.
    207216    typedef typename TR::LengthMap LengthMap;
     
    305314    ///\ref named-templ-param "Named parameter" for setting
    306315    ///\c PredMap type.
    307     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     316    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    308317    template <class T>
    309318    struct SetPredMap
     
    326335    ///\ref named-templ-param "Named parameter" for setting
    327336    ///\c DistMap type.
    328     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     337    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    329338    template <class T>
    330339    struct SetDistMap
     
    347356    ///\ref named-templ-param "Named parameter" for setting
    348357    ///\c ProcessedMap type.
    349     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     358    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    350359    template <class T>
    351360    struct SetProcessedMap
     
    423432    ///passed to the constructor of the cross reference and the cross
    424433    ///reference should be passed to the constructor of the heap).
    425     ///However external heap and cross reference objects could also be
     434    ///However, external heap and cross reference objects could also be
    426435    ///passed to the algorithm using the \ref heap() function before
    427436    ///calling \ref run(Node) "run()" or \ref init().
     
    444453    ///\ref named-templ-param "Named parameter" for setting
    445454    ///\c OperationTraits type.
     455    /// For more information, see \ref DijkstraDefaultOperationTraits.
    446456    template <class T>
    447457    struct SetOperationTraits
     
    585595    ///The simplest way to execute the %Dijkstra algorithm is to use
    586596    ///one of the member functions called \ref run(Node) "run()".\n
    587     ///If you need more control on the execution, first you have to call
    588     ///\ref init(), then you can add several source nodes with
     597    ///If you need better control on the execution, you have to call
     598    ///\ref init() first, then you can add several source nodes with
    589599    ///\ref addSource(). Finally the actual path computation can be
    590600    ///performed with one of the \ref start() functions.
     
    802812    ///The results of the %Dijkstra algorithm can be obtained using these
    803813    ///functions.\n
    804     ///Either \ref run(Node) "run()" or \ref start() should be called
     814    ///Either \ref run(Node) "run()" or \ref init() should be called
    805815    ///before using them.
    806816
    807817    ///@{
    808818
    809     ///The shortest path to a node.
    810 
    811     ///Returns the shortest path to a node.
     819    ///The shortest path to the given node.
     820
     821    ///Returns the shortest path to the given node from the root(s).
    812822    ///
    813823    ///\warning \c t should be reached from the root(s).
     
    817827    Path path(Node t) const { return Path(*G, *_pred, t); }
    818828
    819     ///The distance of a node from the root(s).
    820 
    821     ///Returns the distance of a node from the root(s).
     829    ///The distance of the given node from the root(s).
     830
     831    ///Returns the distance of the given node from the root(s).
    822832    ///
    823833    ///\warning If node \c v is not reached from the root(s), then
     
    828838    Value dist(Node v) const { return (*_dist)[v]; }
    829839
    830     ///Returns the 'previous arc' of the shortest path tree for a node.
    831 
     840    ///\brief Returns the 'previous arc' of the shortest path tree for
     841    ///the given node.
     842    ///
    832843    ///This function returns the 'previous arc' of the shortest path
    833844    ///tree for the node \c v, i.e. it returns the last arc of a
     
    836847    ///
    837848    ///The shortest path tree used here is equal to the shortest path
    838     ///tree used in \ref predNode().
     849    ///tree used in \ref predNode() and \ref predMap().
    839850    ///
    840851    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    842853    Arc predArc(Node v) const { return (*_pred)[v]; }
    843854
    844     ///Returns the 'previous node' of the shortest path tree for a node.
    845 
     855    ///\brief Returns the 'previous node' of the shortest path tree for
     856    ///the given node.
     857    ///
    846858    ///This function returns the 'previous node' of the shortest path
    847859    ///tree for the node \c v, i.e. it returns the last but one node
    848     ///from a shortest path from a root to \c v. It is \c INVALID
     860    ///of a shortest path from a root to \c v. It is \c INVALID
    849861    ///if \c v is not reached from the root(s) or if \c v is a root.
    850862    ///
    851863    ///The shortest path tree used here is equal to the shortest path
    852     ///tree used in \ref predArc().
     864    ///tree used in \ref predArc() and \ref predMap().
    853865    ///
    854866    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    871883    ///
    872884    ///Returns a const reference to the node map that stores the predecessor
    873     ///arcs, which form the shortest path tree.
     885    ///arcs, which form the shortest path tree (forest).
    874886    ///
    875887    ///\pre Either \ref run(Node) "run()" or \ref init()
     
    877889    const PredMap &predMap() const { return *_pred;}
    878890
    879     ///Checks if a node is reached from the root(s).
     891    ///Checks if the given node is reached from the root(s).
    880892
    881893    ///Returns \c true if \c v is reached from the root(s).
     
    896908                                          Heap::POST_HEAP; }
    897909
    898     ///The current distance of a node from the root(s).
    899 
    900     ///Returns the current distance of a node from the root(s).
     910    ///The current distance of the given node from the root(s).
     911
     912    ///Returns the current distance of the given node from the root(s).
    901913    ///It may be decreased in the following processes.
    902914    ///
     
    925937
    926938    ///The type of the map that stores the arc lengths.
    927     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     939    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
    928940    typedef LEN LengthMap;
    929     ///The type of the length of the arcs.
     941    ///The type of the arc lengths.
    930942    typedef typename LEN::Value Value;
    931943
     
    974986    ///The type of the map that stores the predecessor
    975987    ///arcs of the shortest paths.
    976     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     988    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    977989    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    978990    ///Instantiates a PredMap.
     
    9891001
    9901002    ///The type of the map that indicates which nodes are processed.
    991     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    992     ///By default it is a NullMap.
     1003    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     1004    ///By default, it is a NullMap.
    9931005    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    9941006    ///Instantiates a ProcessedMap.
     
    10091021
    10101022    ///The type of the map that stores the distances of the nodes.
    1011     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     1023    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    10121024    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
    10131025    ///Instantiates a DistMap.
     
    10241036
    10251037    ///The type of the shortest paths.
    1026     ///It must meet the \ref concepts::Path "Path" concept.
     1038    ///It must conform to the \ref concepts::Path "Path" concept.
    10271039    typedef lemon::Path<Digraph> Path;
    10281040  };
     
    10301042  /// Default traits class used by DijkstraWizard
    10311043
    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.
     1044  /// Default traits class used by DijkstraWizard.
     1045  /// \tparam GR The type of the digraph.
     1046  /// \tparam LEN The type of the length map.
    10381047  template<typename GR, typename LEN>
    10391048  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
     
    10891098  /// This class should only be used through the \ref dijkstra() function,
    10901099  /// which makes it easier to use the algorithm.
     1100  ///
     1101  /// \tparam TR The traits class that defines various types used by the
     1102  /// algorithm.
    10911103  template<class TR>
    10921104  class DijkstraWizard : public TR
     
    10941106    typedef TR Base;
    10951107
    1096     ///The type of the digraph the algorithm runs on.
    10971108    typedef typename TR::Digraph Digraph;
    10981109
     
    11021113    typedef typename Digraph::OutArcIt OutArcIt;
    11031114
    1104     ///The type of the map that stores the arc lengths.
    11051115    typedef typename TR::LengthMap LengthMap;
    1106     ///The type of the length of the arcs.
    11071116    typedef typename LengthMap::Value Value;
    1108     ///\brief The type of the map that stores the predecessor
    1109     ///arcs of the shortest paths.
    11101117    typedef typename TR::PredMap PredMap;
    1111     ///The type of the map that stores the distances of the nodes.
    11121118    typedef typename TR::DistMap DistMap;
    1113     ///The type of the map that indicates which nodes are processed.
    11141119    typedef typename TR::ProcessedMap ProcessedMap;
    1115     ///The type of the shortest paths
    11161120    typedef typename TR::Path Path;
    1117     ///The heap type used by the dijkstra algorithm.
    11181121    typedef typename TR::Heap Heap;
    11191122
     
    11871190      SetPredMapBase(const TR &b) : TR(b) {}
    11881191    };
    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.
     1192
     1193    ///\brief \ref named-templ-param "Named parameter" for setting
     1194    ///the predecessor map.
     1195    ///
     1196    ///\ref named-templ-param "Named parameter" function for setting
     1197    ///the map that stores the predecessor arcs of the nodes.
    11941198    template<class T>
    11951199    DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
     
    12051209      SetDistMapBase(const TR &b) : TR(b) {}
    12061210    };
    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.
     1211
     1212    ///\brief \ref named-templ-param "Named parameter" for setting
     1213    ///the distance map.
     1214    ///
     1215    ///\ref named-templ-param "Named parameter" function for setting
     1216    ///the map that stores the distances of the nodes calculated
     1217    ///by the algorithm.
    12121218    template<class T>
    12131219    DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
     
    12231229      SetProcessedMapBase(const TR &b) : TR(b) {}
    12241230    };
    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.
     1231
     1232    ///\brief \ref named-func-param "Named parameter" for setting
     1233    ///the processed map.
     1234    ///
     1235    ///\ref named-templ-param "Named parameter" function for setting
     1236    ///the map that indicates which nodes are processed.
    12301237    template<class T>
    12311238    DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
     
    12401247      SetPathBase(const TR &b) : TR(b) {}
    12411248    };
     1249
    12421250    ///\brief \ref named-func-param "Named parameter"
    12431251    ///for getting the shortest path to the target node.
  • lemon/dim2.h

    r463 r761  
    2222#include <iostream>
    2323
    24 ///\ingroup misc
     24///\ingroup geomdat
    2525///\file
    2626///\brief A simple two dimensional vector and a bounding box implementation
    27 ///
    28 /// The class \ref lemon::dim2::Point "dim2::Point" implements
    29 /// a two dimensional vector with the usual operations.
    30 ///
    31 /// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
    32 /// the rectangular bounding box of a set of
    33 /// \ref lemon::dim2::Point "dim2::Point"'s.
    3427
    3528namespace lemon {
     
    4134  namespace dim2 {
    4235
    43   /// \addtogroup misc
     36  /// \addtogroup geomdat
    4437  /// @{
    4538
  • lemon/edge_set.h

    r717 r834  
    256256  /// all arcs incident to the given node is erased from the arc set.
    257257  ///
     258  /// This class fully conforms to the \ref concepts::Digraph
     259  /// "Digraph" concept.
     260  /// It provides only linear time counting for nodes and arcs.
     261  ///
    258262  /// \param GR The type of the graph which shares its node set with
    259263  /// this class. Its interface must conform to the
    260264  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
    261265  /// concept.
    262   ///
    263   /// This class fully conforms to the \ref concepts::Digraph
    264   /// "Digraph" concept.
    265266  template <typename GR>
    266267  class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
     
    686687  /// incident to the given node is erased from the arc set.
    687688  ///
     689  /// This class fully conforms to the \ref concepts::Graph "Graph"
     690  /// concept.
     691  /// It provides only linear time counting for nodes, edges and arcs.
     692  ///
    688693  /// \param GR The type of the graph which shares its node set
    689694  /// with this class. Its interface must conform to the
    690695  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
    691   /// concept.
    692   ///
    693   /// This class fully conforms to the \ref concepts::Graph "Graph"
    694696  /// concept.
    695697  template <typename GR>
     
    868870    }
    869871
    870     void next(Arc& arc) const {
     872    static void next(Arc& arc) {
    871873      --arc.id;
    872874    }
     
    955957  /// arcs. Therefore the arcs cannot be erased from the arc sets.
    956958  ///
     959  /// This class fully conforms to the \ref concepts::Digraph "Digraph"
     960  /// concept.
     961  /// It provides only linear time counting for nodes and arcs.
     962  ///
    957963  /// \warning If a node is erased from the underlying graph and this
    958964  /// node is the source or target of one arc in the arc set, then
    959965  /// the arc set is invalidated, and it cannot be used anymore. The
    960966  /// validity can be checked with the \c valid() member function.
    961   ///
    962   /// This class fully conforms to the \ref concepts::Digraph
    963   /// "Digraph" concept.
    964967  template <typename GR>
    965968  class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
     
    11741177    }
    11751178
    1176     void next(Arc& arc) const {
     1179    static void next(Arc& arc) {
    11771180      --arc.id;
    11781181    }
     
    11821185    }
    11831186
    1184     void next(Edge& arc) const {
     1187    static void next(Edge& arc) {
    11851188      --arc.id;
    11861189    }
     
    13051308  /// edges cannot be erased from the edge sets.
    13061309  ///
     1310  /// This class fully conforms to the \ref concepts::Graph "Graph"
     1311  /// concept.
     1312  /// It provides only linear time counting for nodes, edges and arcs.
     1313  ///
    13071314  /// \warning If a node is erased from the underlying graph and this
    13081315  /// node is incident to one edge in the edge set, then the edge set
    13091316  /// is invalidated, and it cannot be used anymore. The validity can
    13101317  /// be checked with the \c valid() member function.
    1311   ///
    1312   /// This class fully conforms to the \ref concepts::Graph
    1313   /// "Graph" concept.
    13141318  template <typename GR>
    13151319  class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
  • lemon/full_graph.h

    r664 r834  
    2525///\ingroup graphs
    2626///\file
    27 ///\brief FullGraph and FullDigraph classes.
     27///\brief FullDigraph and FullGraph classes.
    2828
    2929namespace lemon {
     
    5252
    5353    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; }
    5555
    5656    Arc arc(const Node& s, const Node& t) const {
     
    149149  /// \ingroup graphs
    150150  ///
    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  /// This class provides constant time counting for nodes and arcs.
     166  ///
     167  /// \note FullDigraph and FullGraph classes are very similar,
    164168  /// but there are two differences. While this class conforms only
    165   /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
    166   /// class conforms to the \ref concepts::Graph "Graph" concept,
    167   /// moreover \c FullGraph does not contain a loop arc for each
    168   /// node as \c FullDigraph does.
     169  /// to the \ref concepts::Digraph "Digraph" concept, FullGraph
     170  /// conforms to the \ref concepts::Graph "Graph" concept,
     171  /// moreover FullGraph does not contain a loop for each
     172  /// node as this class does.
    169173  ///
    170174  /// \sa FullGraph
     
    174178  public:
    175179
    176     /// \brief Constructor
     180    /// \brief Default constructor.
     181    ///
     182    /// Default constructor. The number of nodes and arcs will be zero.
    177183    FullDigraph() { construct(0); }
    178184
     
    185191    /// \brief Resizes the digraph
    186192    ///
    187     /// Resizes the digraph. The function will fully destroy and
    188     /// rebuild the digraph. This cause that the maps of the digraph will
     193    /// This function resizes the digraph. It fully destroys and
     194    /// rebuilds the structure, therefore the maps of the digraph will be
    189195    /// reallocated automatically and the previous values will be lost.
    190196    void resize(int n) {
     
    198204    /// \brief Returns the node with the given index.
    199205    ///
    200     /// Returns the node with the given index. Since it is a static
    201     /// digraph its nodes can be indexed with integers from the range
    202     /// <tt>[0..nodeNum()-1]</tt>.
     206    /// Returns the node with the given index. Since this structure is
     207    /// completely static, the nodes can be indexed with integers from
     208    /// the range <tt>[0..nodeNum()-1]</tt>.
     209    /// The index of a node is the same as its ID.
    203210    /// \sa index()
    204211    Node operator()(int ix) const { return Parent::operator()(ix); }
     
    206213    /// \brief Returns the index of the given node.
    207214    ///
    208     /// Returns the index of the given node. Since it is a static
    209     /// digraph its nodes can be indexed with integers from the range
    210     /// <tt>[0..nodeNum()-1]</tt>.
    211     /// \sa operator()
    212     int index(const Node& node) const { return Parent::index(node); }
     215    /// Returns the index of the given node. Since this structure is
     216    /// completely static, the nodes can be indexed with integers from
     217    /// the range <tt>[0..nodeNum()-1]</tt>.
     218    /// The index of a node is the same as its ID.
     219    /// \sa operator()()
     220    static int index(const Node& node) { return Parent::index(node); }
    213221
    214222    /// \brief Returns the arc connecting the given nodes.
    215223    ///
    216224    /// Returns the arc connecting the given nodes.
    217     Arc arc(const Node& u, const Node& v) const {
     225    Arc arc(Node u, Node v) const {
    218226      return Parent::arc(u, v);
    219227    }
     
    284292
    285293    Node operator()(int ix) const { return Node(ix); }
    286     int index(const Node& node) const { return node._id; }
     294    static int index(const Node& node) { return node._id; }
    287295
    288296    Edge edge(const Node& u, const Node& v) const {
     
    521529  /// \brief An undirected full graph class.
    522530  ///
    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
     531  /// FullGraph is a simple and fast implmenetation of undirected full
     532  /// (complete) graphs. It contains an edge between every distinct pair
     533  /// of nodes, therefore the number of edges is <tt>n(n-1)/2</tt>.
     534  /// This class is completely static and it needs constant memory space.
     535  /// Thus you can neither add nor delete nodes or edges, however
     536  /// the structure can be resized using resize().
     537  ///
     538  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
     539  /// Most of its member functions and nested classes are documented
     540  /// only in the concept class.
     541  ///
     542  /// This class provides constant time counting for nodes, edges and arcs.
     543  ///
     544  /// \note FullDigraph and FullGraph classes are very similar,
     545  /// but there are two differences. While FullDigraph
    534546  /// conforms only to the \ref concepts::Digraph "Digraph" concept,
    535547  /// this class conforms to the \ref concepts::Graph "Graph" concept,
    536   /// moreover \c FullGraph does not contain a loop arc for each
    537   /// node as \c FullDigraph does.
     548  /// moreover this class does not contain a loop for each
     549  /// node as FullDigraph does.
    538550  ///
    539551  /// \sa FullDigraph
     
    543555  public:
    544556
    545     /// \brief Constructor
     557    /// \brief Default constructor.
     558    ///
     559    /// Default constructor. The number of nodes and edges will be zero.
    546560    FullGraph() { construct(0); }
    547561
     
    554568    /// \brief Resizes the graph
    555569    ///
    556     /// Resizes the graph. The function will fully destroy and
    557     /// rebuild the graph. This cause that the maps of the graph will
     570    /// This function resizes the graph. It fully destroys and
     571    /// rebuilds the structure, therefore the maps of the graph will be
    558572    /// reallocated automatically and the previous values will be lost.
    559573    void resize(int n) {
     
    569583    /// \brief Returns the node with the given index.
    570584    ///
    571     /// Returns the node with the given index. Since it is a static
    572     /// graph its nodes can be indexed with integers from the range
    573     /// <tt>[0..nodeNum()-1]</tt>.
     585    /// Returns the node with the given index. Since this structure is
     586    /// completely static, the nodes can be indexed with integers from
     587    /// the range <tt>[0..nodeNum()-1]</tt>.
     588    /// The index of a node is the same as its ID.
    574589    /// \sa index()
    575590    Node operator()(int ix) const { return Parent::operator()(ix); }
     
    577592    /// \brief Returns the index of the given node.
    578593    ///
    579     /// Returns the index of the given node. Since it is a static
    580     /// graph its nodes can be indexed with integers from the range
    581     /// <tt>[0..nodeNum()-1]</tt>.
    582     /// \sa operator()
    583     int index(const Node& node) const { return Parent::index(node); }
     594    /// Returns the index of the given node. Since this structure is
     595    /// completely static, the nodes can be indexed with integers from
     596    /// the range <tt>[0..nodeNum()-1]</tt>.
     597    /// The index of a node is the same as its ID.
     598    /// \sa operator()()
     599    static int index(const Node& node) { return Parent::index(node); }
    584600
    585601    /// \brief Returns the arc connecting the given nodes.
    586602    ///
    587603    /// Returns the arc connecting the given nodes.
    588     Arc arc(const Node& s, const Node& t) const {
     604    Arc arc(Node s, Node t) const {
    589605      return Parent::arc(s, t);
    590606    }
    591607
    592     /// \brief Returns the edge connects the given nodes.
    593     ///
    594     /// Returns the edge connects the given nodes.
    595     Edge edge(const Node& u, const Node& v) const {
     608    /// \brief Returns the edge connecting the given nodes.
     609    ///
     610    /// Returns the edge connecting the given nodes.
     611    Edge edge(Node u, Node v) const {
    596612      return Parent::edge(u, v);
    597613    }
  • lemon/glpk.cc

    r623 r793  
    5757    int i = glp_add_rows(lp, 1);
    5858    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());
    5995    return i;
    6096  }
  • lemon/glpk.h

    r697 r902  
    2626#include <lemon/lp_base.h>
    2727
    28 // forward declaration
    29 #if !defined _GLP_PROB && !defined GLP_PROB
    30 #define _GLP_PROB
    31 #define GLP_PROB
    32 typedef struct { double _opaque_prob; } glp_prob;
    33 /* LP/MIP problem object */
    34 #endif
    35 
    3628namespace lemon {
    3729
     30  namespace _solver_bits {
     31    class VoidPtr {
     32    private:
     33      void *_ptr;     
     34    public:
     35      VoidPtr() : _ptr(0) {}
     36
     37      template <typename T>
     38      VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
     39
     40      template <typename T>
     41      VoidPtr& operator=(T* ptr) {
     42        _ptr = reinterpret_cast<void*>(ptr);
     43        return *this;
     44      }
     45
     46      template <typename T>
     47      operator T*() const { return reinterpret_cast<T*>(_ptr); }
     48    };
     49  }
    3850
    3951  /// \brief Base interface for the GLPK LP and MIP solver
     
    4456  protected:
    4557
    46     typedef glp_prob LPX;
    47     glp_prob* lp;
     58    _solver_bits::VoidPtr lp;
    4859
    4960    GlpkBase();
     
    5566    virtual int _addCol();
    5667    virtual int _addRow();
     68    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    5769
    5870    virtual void _eraseCol(int i);
     
    123135
    124136    ///Pointer to the underlying GLPK data structure.
    125     LPX *lpx() {return lp;}
     137    _solver_bits::VoidPtr lpx() {return lp;}
    126138    ///Const pointer to the underlying GLPK data structure.
    127     const LPX *lpx() const {return lp;}
     139    _solver_bits::VoidPtr lpx() const {return lp;}
    128140
    129141    ///Returns the constraint identifier understood by GLPK.
  • lemon/gomory_hu.h

    r643 r833  
    295295    /// \pre \ref run() must be called before using this function.
    296296    template <typename CutMap>
    297     Value minCutMap(const Node& s, ///<
     297    Value minCutMap(const Node& s,
    298298                    const Node& t,
    299                     ///<
    300299                    CutMap& cutMap
    301                     ///<
    302300                    ) const {
    303301      Node sn = s, tn = t;
     
    360358    /// \c t.
    361359    /// \code
    362     /// GomoruHu<Graph> gom(g, capacities);
     360    /// GomoryHu<Graph> gom(g, capacities);
    363361    /// gom.run();
    364362    /// int cnt=0;
    365     /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
     363    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
    366364    /// \endcode
    367365    class MinCutNodeIt
     
    395393                   /// \endcode
    396394                   /// does not necessarily give the same set of nodes.
    397                    /// However it is ensured that
     395                   /// However, it is ensured that
    398396                   /// \code
    399397                   /// MinCutNodeIt(gomory, s, t, true);
     
    457455    /// \c t.
    458456    /// \code
    459     /// GomoruHu<Graph> gom(g, capacities);
     457    /// GomoryHu<Graph> gom(g, capacities);
    460458    /// gom.run();
    461459    /// int value=0;
    462     /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
     460    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
    463461    ///   value+=capacities[e];
    464462    /// \endcode
  • lemon/graph_to_eps.h

    r664 r909  
    143143  ///\param gr  Reference to the graph to be printed.
    144144  ///\param ost Reference to the output stream.
    145   ///By default it is <tt>std::cout</tt>.
     145  ///By default, it is <tt>std::cout</tt>.
    146146  ///\param pros If it is \c true, then the \c ostream referenced by \c os
    147147  ///will be explicitly deallocated by the destructor.
     
    513513  ///Turn on/off pre-scaling
    514514
    515   ///By default graphToEps() rescales the whole image in order to avoid
     515  ///By default, graphToEps() rescales the whole image in order to avoid
    516516  ///very big or very small bounding boxes.
    517517  ///
     
    685685#else
    686686      os << bits::getWinFormattedDate();
     687      os << std::endl;
    687688#endif
    688689    }
    689     os << std::endl;
    690690
    691691    if (_autoArcWidthScale) {
     
    11151115///\param g Reference to the graph to be printed.
    11161116///\param os Reference to the output stream.
    1117 ///By default it is <tt>std::cout</tt>.
     1117///By default, it is <tt>std::cout</tt>.
    11181118///
    11191119///This function also has a lot of
     
    11271127///\endcode
    11281128///
    1129 ///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
     1129///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file.
    11301130///
    11311131///\warning Don't forget to put the \ref GraphToEps::run() "run()"
  • lemon/grid_graph.h

    r664 r834  
    471471  /// \brief Grid graph class
    472472  ///
    473   /// This class implements a special graph type. The nodes of the
    474   /// graph can be indexed by two integer \c (i,j) value where \c i is
    475   /// in the \c [0..width()-1] range and j is in the \c
    476   /// [0..height()-1] range. Two nodes are connected in the graph if
    477   /// the indexes differ exactly on one position and exactly one is
    478   /// the difference. The nodes of the graph can be indexed by position
    479   /// with the \c operator()() function. The positions of the nodes can be
    480   /// get with \c pos(), \c col() and \c row() members. The outgoing
     473  /// 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
    481481  /// arcs can be retrieved with the \c right(), \c up(), \c left()
    482482  /// and \c down() functions, where the bottom-left corner is the
    483483  /// 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().
    484488  ///
    485489  /// \image html grid_graph.png
     
    497501  ///\endcode
    498502  ///
    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.
     506  ///
     507  /// This class provides constant time counting for nodes, edges and arcs.
    501508  class GridGraph : public ExtendedGridGraphBase {
    502509    typedef ExtendedGridGraphBase Parent;
     
    504511  public:
    505512
    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>.
     513    /// \brief Map to get the indices of the nodes as \ref dim2::Point
     514    /// "dim2::Point<int>".
     515    ///
     516    /// Map to get the indices of the nodes as \ref dim2::Point
     517    /// "dim2::Point<int>".
    509518    class IndexMap {
    510519    public:
     
    515524
    516525      /// \brief Constructor
    517       ///
    518       /// Constructor
    519526      IndexMap(const GridGraph& graph) : _graph(graph) {}
    520527
    521528      /// \brief The subscript operator
    522       ///
    523       /// The subscript operator.
    524529      Value operator[](Key key) const {
    525530        return _graph.pos(key);
     
    541546
    542547      /// \brief Constructor
    543       ///
    544       /// Constructor
    545548      ColMap(const GridGraph& graph) : _graph(graph) {}
    546549
    547550      /// \brief The subscript operator
    548       ///
    549       /// The subscript operator.
    550551      Value operator[](Key key) const {
    551552        return _graph.col(key);
     
    567568
    568569      /// \brief Constructor
    569       ///
    570       /// Constructor
    571570      RowMap(const GridGraph& graph) : _graph(graph) {}
    572571
    573572      /// \brief The subscript operator
    574       ///
    575       /// The subscript operator.
    576573      Value operator[](Key key) const {
    577