COIN-OR::LEMON - Graph Library

Changeset 1946:17eb3eaad9f8 in lemon-0.x for lemon


Ignore:
Timestamp:
02/02/06 18:43:24 (14 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2521
Message:
  • workaround for a Doxygen 1.4.6 bug
  • other doc fixes
Location:
lemon
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • lemon/bellman_ford.h

    r1875 r1946  
    545545    ///
    546546    /// \note d.run(s) is just a shortcut of the following code.
    547     /// \code
     547    ///\code
    548548    ///  d.init();
    549549    ///  d.addSource(s);
    550550    ///  d.start();
    551     /// \endcode
     551    ///\endcode
    552552    void run(Node s) {
    553553      init();
     
    566566    ///
    567567    /// \note d.run(s, len) is just a shortcut of the following code.
    568     /// \code
     568    ///\code
    569569    ///  d.init();
    570570    ///  d.addSource(s);
    571571    ///  d.limitedStart(len);
    572     /// \endcode
     572    ///\endcode
    573573    void run(Node s, int len) {
    574574      init();
     
    929929  /// The following
    930930  /// example shows how to use these parameters.
    931   /// \code
     931  ///\code
    932932  /// bellmanford(g,length,source).predMap(preds).run();
    933   /// \endcode
     933  ///\endcode
    934934  /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
    935935  /// to the end of the parameter list.
  • lemon/bits/alteration_notifier.h

    r1910 r1946  
    2121#include <algorithm>
    2222
    23 ///\ingroin graphmapfactory
     23///\ingroup graphmapfactory
    2424///\file
    2525///\brief Observer registry for graph alteration observers.
  • lemon/bits/array_map.h

    r1910 r1946  
    2424#include <lemon/concept/maps.h>
    2525
    26 /// \ingroin graphmapfactory
     26/// \ingroup graphmapfactory
    2727/// \file
    2828/// \brief Graph maps that construct and destruct
     
    3131namespace lemon {
    3232
    33   /// \ingroin graphmapfactory
     33  /// \ingroup graphmapfactory
    3434  ///
    3535  /// \brief Graph map based on the array storage.
  • lemon/bits/default_map.h

    r1910 r1946  
    2222#include <lemon/bits/vector_map.h>
    2323
    24 ///\ingroin graphmapfactory
     24///\ingroup graphmapfactory
    2525///\file
    2626///\brief Graph maps that construct and destruct
  • lemon/bits/item_reader.h

    r1910 r1946  
    1616
    1717/// @defgroin item_io Item Readers and Writers
    18 /// @ingroin io_groin
     18/// @ingroup io_groin
    1919/// \brief Item Readers and Writers
    2020///
     
    2323/// read some way. The module make possible to do this. 
    2424
    25 /// \ingroin item_io
     25/// \ingroup item_io
    2626/// \file
    2727/// \brief Item reader bits for lemon input.
     
    4343  class DefaultReader;
    4444
    45   /// \ingroin item_io
     45  /// \ingroup item_io
    4646  ///
    4747  /// \brief Reader class for quoted strings.
     
    158158  };
    159159
    160   /// \ingroin item_io
     160  /// \ingroup item_io
    161161  /// \brief Reader for standard containers.
    162162  ///
     
    205205  };
    206206
    207   /// \ingroin item_io
     207  /// \ingroup item_io
    208208  ///
    209209  /// \brief Reader for standard containers.
     
    253253  };
    254254
    255   /// \ingroin item_io
     255  /// \ingroup item_io
    256256  /// \brief Reader for parsed string.
    257257  ///
     
    301301  };
    302302
    303   /// \ingroin item_io
     303  /// \ingroup item_io
    304304  /// \brief Reader for read the whole line.
    305305  ///
     
    331331  };
    332332
    333   /// \ingroin item_io
     333  /// \ingroup item_io
    334334  /// \brief Reader for std::pair.
    335335  ///
     
    385385  };
    386386
    387   /// \ingroin item_io
     387  /// \ingroup item_io
    388388  ///
    389389  /// \brief The default item reader template class.
     
    472472    : public PairReader<std::pair<First, Second> > {};
    473473
    474   /// \ingroin item_io
     474  /// \ingroup item_io
    475475  ///
    476476  /// \brief The default item reader for skipping a value in the stream.
     
    481481  class DefaultSkipper : public DefaultReader<std::string> {};
    482482
    483   /// \ingroin item_io 
     483  /// \ingroup item_io 
    484484  /// \brief Standard ReaderTraits for the GraphReader class.
    485485  ///
  • lemon/bits/item_writer.h

    r1910 r1946  
    1515 */
    1616
    17 /// \ingroin item_io
     17/// \ingroup item_io
    1818/// \file
    1919/// \brief Item writer bits for lemon output.
     
    3535  class DefaultWriter;
    3636
    37   /// \ingroin item_io
     37  /// \ingroup item_io
    3838  /// \brief Writer class for quoted strings.
    3939  ///
     
    118118  };
    119119
    120   /// \ingroin item_io
     120  /// \ingroup item_io
    121121  /// \brief Writer class for quoted char array.
    122122  ///
     
    146146
    147147
    148   /// \ingroin item_io
     148  /// \ingroup item_io
    149149  ///
    150150  /// \brief Writer for standard containers.
     
    188188  };
    189189
    190   /// \ingroin item_io
     190  /// \ingroup item_io
    191191  ///
    192192  /// \brief Writer for standard pairs.
    193193  ///
    194194  /// Writer for standard pairs. The representation of a pair is
    195   /// \code ( first_value => second_value ) \endcode.
     195  ///\code ( first_value => second_value ) \endcode.
    196196  /// \author Balazs Dezso
    197197  template <typename _Pair,
     
    235235  };
    236236
    237   /// \ingroin item_io
     237  /// \ingroup item_io
    238238  ///
    239239  /// \brief The default item writer template class.
     
    308308    : public PairWriter<std::pair<First, Second> > {};
    309309
    310   /// \ingroin item_io
     310  /// \ingroup item_io
    311311  /// \brief Standard WriterTraits for the section writers.
    312312  ///
  • lemon/bits/static_map.h

    r1910 r1946  
    2828#include <lemon/concept/maps.h>
    2929
    30 /// \ingroin graphmaps
     30/// \ingroup graphmaps
    3131///
    3232///\file
     
    3535namespace lemon {
    3636
    37   /// \ingroin graphmaps
     37  /// \ingroup graphmaps
    3838  ///
    3939  /// \brief Graph map with static sized storage.
  • lemon/bits/vector_map.h

    r1910 r1946  
    2727#include <lemon/concept/maps.h>
    2828
    29 /// \ingroin graphmapfactory
     29/// \ingroup graphmapfactory
    3030///
    3131///\file
     
    3434namespace lemon {
    3535
    36   /// \ingroin graphmapfactory
     36  /// \ingroup graphmapfactory
    3737  ///
    3838  /// \brief Graph map based on the std::vector storage.
  • lemon/concept/bpugraph.h

    r1933 r1946  
    245245      /// Its usage is quite simple, for example you can count the number
    246246      /// of nodes in graph \c g of type \c Graph like this:
    247       /// \code
     247      ///\code
    248248      /// int count=0;
    249249      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
    250       /// \endcode
     250      ///\endcode
    251251      class NodeIt : public Node {
    252252      public:
     
    290290      /// Its usage is quite simple, for example you can count the number
    291291      /// of nodes in graph \c g of type \c Graph like this:
    292       /// \code
     292      ///\code
    293293      /// int count=0;
    294294      /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
    295       /// \endcode
     295      ///\endcode
    296296      class ANodeIt : public ANode {
    297297      public:
     
    335335      /// Its usage is quite simple, for example you can count the number
    336336      /// of nodes in graph \c g of type \c Graph like this:
    337       /// \code
     337      ///\code
    338338      /// int count=0;
    339339      /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
    340       /// \endcode
     340      ///\endcode
    341341      class BNodeIt : public BNode {
    342342      public:
     
    426426      /// Its usage is quite simple, for example you can count the number
    427427      /// of undirected edges in a graph \c g of type \c Graph as follows:
    428       /// \code
     428      ///\code
    429429      /// int count=0;
    430430      /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
    431       /// \endcode
     431      ///\endcode
    432432      class UEdgeIt : public UEdge {
    433433      public:
     
    474474      /// of incident edges of a node \c n
    475475      /// in graph \c g of type \c Graph as follows.
    476       /// \code
     476      ///\code
    477477      /// int count=0;
    478478      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    479       /// \endcode
     479      ///\endcode
    480480      class IncEdgeIt : public UEdge {
    481481      public:
     
    563563      /// Its usage is quite simple, for example you can count the number
    564564      /// of edges in a graph \c g of type \c Graph as follows:
    565       /// \code
     565      ///\code
    566566      /// int count=0;
    567567      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
    568       /// \endcode
     568      ///\endcode
    569569      class EdgeIt : public Edge {
    570570      public:
     
    608608      /// of outgoing edges of a node \c n
    609609      /// in graph \c g of type \c Graph as follows.
    610       /// \code
     610      ///\code
    611611      /// int count=0;
    612612      /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    613       /// \endcode
     613      ///\endcode
    614614   
    615615      class OutEdgeIt : public Edge {
     
    660660      /// of outgoing edges of a node \c n
    661661      /// in graph \c g of type \c Graph as follows.
    662       /// \code
     662      ///\code
    663663      /// int count=0;
    664664      /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    665       /// \endcode
     665      ///\endcode
    666666
    667667      class InEdgeIt : public Edge {
  • lemon/concept/graph.h

    r1909 r1946  
    193193      /// Its usage is quite simple, for example you can count the number
    194194      /// of nodes in graph \c g of type \c Graph like this:
    195       /// \code
     195      ///\code
    196196      /// int count=0;
    197197      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
    198       /// \endcode
     198      ///\endcode
    199199      class NodeIt : public Node {
    200200      public:
     
    286286      /// of outgoing edges of a node \c n
    287287      /// in graph \c g of type \c Graph as follows.
    288       /// \code
     288      ///\code
    289289      /// int count=0;
    290290      /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    291       /// \endcode
     291      ///\endcode
    292292   
    293293      class OutEdgeIt : public Edge {
     
    333333      /// of outgoing edges of a node \c n
    334334      /// in graph \c g of type \c Graph as follows.
    335       /// \code
     335      ///\code
    336336      /// int count=0;
    337337      /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    338       /// \endcode
     338      ///\endcode
    339339
    340340      class InEdgeIt : public Edge {
     
    377377      /// Its usage is quite simple, for example you can count the number
    378378      /// of edges in a graph \c g of type \c Graph as follows:
    379       /// \code
     379      ///\code
    380380      /// int count=0;
    381381      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
    382       /// \endcode
     382      ///\endcode
    383383      class EdgeIt : public Edge {
    384384      public:
  • lemon/concept/ugraph.h

    r1910 r1946  
    305305      /// Its usage is quite simple, for example you can count the number
    306306      /// of nodes in graph \c g of type \c Graph like this:
    307       /// \code
     307      ///\code
    308308      /// int count=0;
    309309      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
    310       /// \endcode
     310      ///\endcode
    311311      class NodeIt : public Node {
    312312      public:
     
    396396      /// Its usage is quite simple, for example you can count the number
    397397      /// of undirected edges in a graph \c g of type \c Graph as follows:
    398       /// \code
     398      ///\code
    399399      /// int count=0;
    400400      /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
    401       /// \endcode
     401      ///\endcode
    402402      class UEdgeIt : public UEdge {
    403403      public:
     
    444444      /// of incident edges of a node \c n
    445445      /// in graph \c g of type \c Graph as follows.
    446       /// \code
     446      ///\code
    447447      /// int count=0;
    448448      /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    449       /// \endcode
     449      ///\endcode
    450450      class IncEdgeIt : public UEdge {
    451451      public:
     
    533533      /// Its usage is quite simple, for example you can count the number
    534534      /// of edges in a graph \c g of type \c Graph as follows:
    535       /// \code
     535      ///\code
    536536      /// int count=0;
    537537      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
    538       /// \endcode
     538      ///\endcode
    539539      class EdgeIt : public Edge {
    540540      public:
     
    578578      /// of outgoing edges of a node \c n
    579579      /// in graph \c g of type \c Graph as follows.
    580       /// \code
     580      ///\code
    581581      /// int count=0;
    582582      /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    583       /// \endcode
     583      ///\endcode
    584584   
    585585      class OutEdgeIt : public Edge {
     
    630630      /// of outgoing edges of a node \c n
    631631      /// in graph \c g of type \c Graph as follows.
    632       /// \code
     632      ///\code
    633633      /// int count=0;
    634634      /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
    635       /// \endcode
     635      ///\endcode
    636636
    637637      class InEdgeIt : public Edge {
  • lemon/dag_shortest_path.h

    r1912 r1946  
    117117    ///
    118118    /// This function instantiates a \ref PredMap.
    119     /// \param G is the graph, to which we would like to define the PredMap.
     119    /// \param graph is the graph, to which we would
     120    /// like to define the PredMap.
    120121    /// \todo The graph alone may be insufficient for the initialization
    121122    static PredMap *createPredMap(const _Graph& graph) {
     
    134135    ///
    135136    /// This function instantiates a \ref DistMap.
    136     /// \param G is the graph, to which we would like to define the
     137    /// \param graph is the graph, to which we would like to define the
    137138    /// \ref DistMap
    138139    static DistMap *createDistMap(const _Graph& graph) {
     
    228229    ///
    229230    /// This function instantiates a \ref PredMap.
    230     /// \param G is the graph, to which we would like to define the PredMap.
     231    /// \param graph is the graph,
     232    /// to which we would like to define the PredMap.
    231233    /// \todo The graph alone may be insufficient for the initialization
    232234    static PredMap *createPredMap(const _Graph& graph) {
     
    245247    ///
    246248    /// This function instantiates a \ref DistMap.
    247     /// \param G is the graph, to which we would like to define the
     249    /// \param graph is the graph, to which we would like to define the
    248250    /// \ref DistMap
    249251    static DistMap *createDistMap(const _Graph& graph) {
     
    682684    ///
    683685    /// \note d.run(s) is just a shortcut of the following code.
    684     /// \code
     686    ///\code
    685687    ///  d.init();
    686688    ///  d.addSource(s);
    687689    ///  d.start();
    688     /// \endcode
     690    ///\endcode
    689691    void run(Node s) {
    690692      init();
     
    978980    ///
    979981    /// Runs DagShortestPath algorithm from the given node.
    980     /// \param s is the given source.
     982    /// \param source is the given source.
    981983    void run(Node source) {
    982984      Base::_source = source;
     
    10431045    ///
    10441046    /// Sets the source node, from which the DagShortestPath algorithm runs.
    1045     /// \param s is the source node.
     1047    /// \param source is the source node.
    10461048    DagShortestPathWizard<_Traits>& source(Node source) {
    10471049      Base::_source = source;
     
    10611063  /// The following
    10621064  /// example shows how to use these parameters.
    1063   /// \code
     1065  ///\code
    10641066  /// dagShortestPath(g,length,source).predMap(preds).run();
    1065   /// \endcode
     1067  ///\endcode
    10661068  /// \warning Don't forget to put the \ref DagShortestPathWizard::run() "run()"
    10671069  /// to the end of the parameter list.
  • lemon/dfs.h

    r1875 r1946  
    14431443    /// This method runs the %DFS algorithm from a root node \c s.
    14441444    /// \note d.run(s) is just a shortcut of the following code.
    1445     /// \code
     1445    ///\code
    14461446    ///   d.init();
    14471447    ///   d.addSource(s);
    14481448    ///   d.start();
    1449     /// \endcode
     1449    ///\endcode
    14501450    void run(Node s) {
    14511451      init();
  • lemon/dimacs.h

    r1875 r1946  
    4545  /// This function reads a min cost flow instance from dimacs format,
    4646  /// i.e. from dimacs files having a line starting with
    47   /// \code
     47  ///\code
    4848  /// p "min"
    49   /// \endcode
     49  ///\endcode
    5050  /// At the beginning \c g is cleared by \c g.clear(). The edge
    5151  /// capacities are written to \c capacity, \c s and \c t are set to
     
    125125  /// This function reads a max flow instance from dimacs format,
    126126  /// i.e. from dimacs files having a line starting with
    127   /// \code
     127  ///\code
    128128  /// p "max"
    129   /// \endcode
     129  ///\endcode
    130130  ///At the beginning \c g is cleared by \c g.clear(). The
    131131  /// edge capacities are written to \c capacity and \c s and \c t are
     
    145145  /// This function reads a shortest path instance from dimacs format,
    146146  /// i.e. from dimacs files having a line starting with
    147   /// \code
     147  ///\code
    148148  /// p "sp"
    149   /// \endcode
     149  ///\endcode
    150150  /// At the beginning \c g is cleared by \c g.clear(). The edge
    151151  /// capacities are written to \c capacity and \c s is set to the
     
    181181  /// maps from dimacs format, i.e. from dimacs files having a line
    182182  /// starting with
    183   /// \code
     183  ///\code
    184184  /// p "mat"
    185   /// \endcode
     185  ///\endcode
    186186  /// At the beginning \c g is cleared
    187187  /// by \c g.clear().
  • lemon/floyd_warshall.h

    r1875 r1946  
    118118    ///
    119119    /// This function instantiates a \ref PredMap.
    120     /// \param G is the graph, to which we would like to define the PredMap.
     120    /// \param graph is the graph,
     121    /// to which we would like to define the PredMap.
    121122    /// \todo The graph alone may be insufficient for the initialization
    122123    static PredMap *createPredMap(const _Graph& graph) {
     
    134135    ///
    135136    /// This function instantiates a \ref DistMap.
    136     /// \param G is the graph, to which we would like to define the
     137    /// \param graph is the graph, to which we would like to define the
    137138    /// \ref DistMap
    138139    static DistMap *createDistMap(const _Graph& graph) {
     
    455456    ///
    456457    /// \note d.run(s) is just a shortcut of the following code.
    457     /// \code
     458    ///\code
    458459    ///  d.init();
    459460    ///  d.start();
    460     /// \endcode
     461    ///\endcode
    461462    void run() {
    462463      init();
  • lemon/fredman_tarjan.h

    r1912 r1946  
    6666
    6767    ///This function instantiates a \ref TreeMap.
    68     ///\param g is the graph, to which
     68    ///\param _graph is the graph, to which
    6969    ///we would like to define the \ref TreeMap
    7070    static TreeMap *createTreeMap(const GR &_graph){
  • lemon/graph_adaptor.h

    r1909 r1946  
    189189  /// suppose that a graph instange \c g of type
    190190  /// \c ListGraph implements \f$G\f$.
    191   /// \code
     191  ///\code
    192192  /// ListGraph g;
    193   /// \endcode
     193  ///\endcode
    194194  /// For each directed edge
    195195  /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by
     
    200200  /// reversing the orientation of its edges. The following code shows how
    201201  /// such an instance can be constructed.
    202   /// \code
     202  ///\code
    203203  /// RevGraphAdaptor<ListGraph> gw(g);
    204   /// \endcode
     204  ///\endcode
    205205  ///\author Marton Makai
     206
    206207  template<typename _Graph>
    207208  class RevGraphAdaptor :
     
    12791280  /// For blocking flows.
    12801281
    1281   ///\warning Graph adaptors are in even more experimental state than the other
     1282  ///\warning Graph adaptors are in even more
     1283  ///experimental state than the other
    12821284  ///parts of the lib. Use them at you own risk.
    12831285  ///
    1284   /// This graph adaptor is used for on-the-fly
    1285   /// Dinits blocking flow computations.
    1286   /// For each node, an out-edge is stored which is used when the
    1287   /// \code
    1288   /// OutEdgeIt& first(OutEdgeIt&, const Node&)
    1289   /// \endcode
    1290   /// is called.
     1286  ///This graph adaptor is used for on-the-fly
     1287  ///Dinits blocking flow computations.
     1288  ///For each node, an out-edge is stored which is used when the
     1289  ///\code OutEdgeIt& first(OutEdgeIt&, const Node&)\endcode
     1290  ///is called.
    12911291  ///
    1292   /// \author Marton Makai
     1292  ///\author Marton Makai
     1293  ///
    12931294  template <typename _Graph, typename FirstOutEdgesMap>
    12941295  class ErasingFirstGraphAdaptor :
  • lemon/graph_reader.h

    r1935 r1946  
    5555  /// it should skip the values when the string representation contains spaces.
    5656  ///
    57   /// \code
     57  ///\code
    5858  /// GraphReader<ListGraph> reader(std::cin, graph);
    59   /// \endcode
     59  ///\endcode
    6060  ///
    6161  /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
     
    6565  /// parameters.
    6666  ///
    67   /// \code
     67  ///\code
    6868  /// reader.readNodeMap("coords", coords);
    6969  ///
     
    7171  ///
    7272  /// reader.readNodeMap("color", colorMap);
    73   /// \endcode
     73  ///\endcode
    7474  ///
    7575  /// With the \c readEdgeMap() member function you can give an edge map
    7676  /// reading command similar to the NodeMaps.
    7777  ///
    78   /// \code
     78  ///\code
    7979  /// reader.readEdgeMap("weight", weightMap);
    8080  /// reader.readEdgeMap("label", labelMap);
    81   /// \endcode
     81  ///\endcode
    8282  ///
    8383  /// With \c readNode() and \c readEdge() functions you can read
    8484  /// labeled Nodes and Edges.
    8585  ///
    86   /// \code
     86  ///\code
    8787  /// reader.readNode("source", sourceNode);
    8888  /// reader.readNode("target", targetNode);
    8989  ///
    9090  /// reader.readEdge("observed", edge);
    91   /// \endcode
     91  ///\endcode
    9292  ///
    9393  /// With the \c readAttribute() functions you can read an attribute
     
    9898  /// function, which executes all the commands.
    9999  ///
    100   /// \code
     100  ///\code
    101101  /// reader.run();
    102   /// \endcode
     102  ///\endcode
    103103  ///
    104104  /// \see DefaultReaderTraits
     
    399399  /// it should skip the values when the string representation contains spaces.
    400400  ///
    401   /// \code
     401  ///\code
    402402  /// UGraphReader<ListUGraph> reader(std::cin, graph);
    403   /// \endcode
     403  ///\endcode
    404404  ///
    405405  /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
     
    409409  /// parameters.
    410410  ///
    411   /// \code
     411  ///\code
    412412  /// reader.readNodeMap("coords", coords);
    413413  ///
     
    415415  ///
    416416  /// reader.readNodeMap("color", colorMap);
    417   /// \endcode
     417  ///\endcode
    418418  ///
    419419  /// With the \c readUEdgeMap() member function you can give an
    420420  /// uedge map reading command similar to the NodeMaps.
    421421  ///
    422   /// \code
     422  ///\code
    423423  /// reader.readUEdgeMap("capacity", capacityMap);
    424   /// \endcode
     424  ///\endcode
    425425  ///
    426426  /// The reading of the directed edge maps is just a syntactical sugar.
     
    429429  /// \c '-' character and the same.
    430430  ///
    431   /// \code
     431  ///\code
    432432  /// reader.readEdgeMap("flow", flowMap);
    433   /// \endcode
     433  ///\endcode
    434434  ///
    435435  /// With \c readNode() and \c readUEdge() functions you can read
    436436  /// labeled Nodes and UEdges.
    437437  ///
    438   /// \code
     438  ///\code
    439439  /// reader.readNode("source", sourceNode);
    440440  /// reader.readNode("target", targetNode);
    441441  ///
    442442  /// reader.readUEdge("observed", uEdge);
    443   /// \endcode
     443  ///\endcode
    444444  ///
    445445  /// With the \c readAttribute() functions you can read an attribute
     
    450450  /// function, which execute all the commands.
    451451  ///
    452   /// \code
     452  ///\code
    453453  /// reader.run();
    454   /// \endcode
     454  ///\endcode
    455455  ///
    456456  /// \see GraphReader
  • lemon/graph_utils.h

    r1931 r1946  
    259259  ///
    260260  /// Thus you can iterate through each edge from \c u to \c v as it follows.
    261   /// \code
     261  ///\code
    262262  /// for(Edge e=findEdge(g,u,v);e!=INVALID;e=findEdge(g,u,v,e)) {
    263263  ///   ...
    264264  /// }
    265   /// \endcode
     265  ///\endcode
    266266  // /// \todo We may want to use the "GraphBase"
    267267  // /// interface here...
     
    279279  /// higher level interface for the findEdge() function. You can
    280280  /// use it the following way:
    281   /// \code
     281  ///\code
    282282  /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
    283283  ///   ...
    284284  /// }
    285   /// \endcode
     285  ///\endcode
    286286  ///
    287287  /// \author Balazs Dezso
     
    361361  ///
    362362  /// Thus you can iterate through each edge from \c u to \c v as it follows.
    363   /// \code
     363  ///\code
    364364  /// for(UEdge e = findUEdge(g,u,v); e != INVALID;
    365365  ///     e = findUEdge(g,u,v,e)) {
    366366  ///   ...
    367367  /// }
    368   /// \endcode
     368  ///\endcode
    369369  // /// \todo We may want to use the "GraphBase"
    370370  // /// interface here...
     
    383383  /// higher level interface for the findUEdge() function. You can
    384384  /// use it the following way:
    385   /// \code
     385  ///\code
    386386  /// for (ConUEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
    387387  ///   ...
    388388  /// }
    389   /// \endcode
     389  ///\endcode
    390390  ///
    391391  /// \author Balazs Dezso
     
    581581  /// The usage of the function:
    582582  ///
    583   /// \code
     583  ///\code
    584584  /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
    585   /// \endcode
     585  ///\endcode
    586586  ///
    587587  /// After the copy the \c nr map will contain the mapping from the
     
    793793  /// The usage of the function:
    794794  ///
    795   /// \code
     795  ///\code
    796796  /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
    797   /// \endcode
     797  ///\endcode
    798798  ///
    799799  /// After the copy the \c nr map will contain the mapping from the
  • lemon/graph_writer.h

    r1909 r1946  
    4848  /// Edge writing.
    4949  ///
    50   /// \code
     50  ///\code
    5151  /// GraphWriter<ListGraph> writer(std::cout, graph);
    52   /// \endcode
     52  ///\endcode
    5353  ///
    5454  /// The \c writeNodeMap() function declares a \c NodeMap writing
     
    5858  /// is regarded as label map (such a map is essential if the graph has edges).
    5959  ///
    60   /// \code
     60  ///\code
    6161  /// IdMap<ListGraph, Node> nodeLabelMap;
    6262  /// writer.writeNodeMap("label", nodeLabelMap);
     
    6464  /// writer.writeNodeMap("coords", coords);
    6565  /// writer.writeNodeMap("color", colorMap);
    66   /// \endcode
     66  ///\endcode
    6767  ///
    6868  /// With the \c writeEdgeMap() member function you can give an edge map
    6969  /// writing command similar to the NodeMaps.
    7070  ///
    71   /// \code
     71  ///\code
    7272  /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
    7373  ///   edgeDescMap(graph);
     
    7676  /// writer.writeEdgeMap("weight", weightMap);
    7777  /// writer.writeEdgeMap("label", labelMap);
    78   /// \endcode
     78  ///\endcode
    7979  ///
    8080  /// With \c writeNode() and \c writeEdge() functions you can
     
    8282  /// write out the source and target of a maximum flow instance.
    8383  ///
    84   /// \code
     84  ///\code
    8585  /// writer.writeNode("source", sourceNode);
    8686  /// writer.writeNode("target", targetNode);
    8787  ///
    8888  /// writer.writeEdge("observed", edge);
    89   /// \endcode
     89  ///\endcode
    9090  ///
    9191  /// After you give all write commands you must call the \c run() member
    9292  /// function, which executes all the writing commands.
    9393  ///
    94   /// \code
     94  ///\code
    9595  /// writer.run();
    96   /// \endcode
     96  ///\endcode
    9797  ///
    9898  /// \see DefaultWriterTraits
     
    321321  /// writing and labeled Node, Edge or UEdge writing.
    322322  ///
    323   /// \code
     323  ///\code
    324324  /// UGraphWriter<ListUGraph> writer(std::cout, graph);
    325   /// \endcode
     325  ///\endcode
    326326  ///
    327327  /// The \c writeNodeMap() function declares a \c NodeMap writing
     
    331331  /// is regarded as label map.
    332332  ///
    333   /// \code
     333  ///\code
    334334  /// IdMap<ListUGraph, Node> nodeLabelMap;
    335335  /// writer.writeNodeMap("label", nodeLabelMap);
     
    337337  /// writer.writeNodeMap("coords", coords);
    338338  /// writer.writeNodeMap("color", colorMap);
    339   /// \endcode
     339  ///\endcode
    340340  ///
    341341  /// With the \c writeUEdgeMap() member function you can give an
    342342  /// undirected edge map writing command similar to the NodeMaps.
    343343  ///
    344   /// \code
     344  ///\code
    345345  /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
    346346  ///   edgeDescMap(graph);
     
    349349  /// writer.writeUEdgeMap("weight", weightMap);
    350350  /// writer.writeUEdgeMap("label", labelMap);
    351   /// \endcode
     351  ///\endcode
    352352  ///
    353353  /// The EdgeMap handling is just a syntactical sugar. It writes
    354354  /// two undirected edge map with '+' and '-' prefix in the name.
    355355  ///
    356   /// \code
     356  ///\code
    357357  /// writer.writeEdgeMap("capacity", capacityMap);
    358   /// \endcode
     358  ///\endcode
    359359  ///
    360360  ///
     
    363363  /// write out the source and target of the graph.
    364364  ///
    365   /// \code
     365  ///\code
    366366  /// writer.writeNode("source", sourceNode);
    367367  /// writer.writeNode("target", targetNode);
    368368  ///
    369369  /// writer.writeUEdge("observed", uEdge);
    370   /// \endcode
     370  ///\endcode
    371371  ///
    372372  /// After you give all write commands you must call the \c run() member
    373373  /// function, which executes all the writing commands.
    374374  ///
    375   /// \code
     375  ///\code
    376376  /// writer.run();
    377   /// \endcode
     377  ///\endcode
    378378  ///
    379379  /// \see DefaultWriterTraits
  • lemon/grid_graph.h

    r1909 r1946  
    355355  ///
    356356  /// The graph can be indiced in the following way:
    357   /// \code
     357  ///\code
    358358  /// GridGraph graph(w, h);
    359359  /// GridGraph::NodeMap<int> val(graph);
     
    363363  ///   }
    364364  /// }
    365   /// \endcode
     365  ///\endcode
    366366  ///
    367367  /// The graph type is fully conform to the \ref concept::UGraph
  • lemon/hypercube_graph.h

    r1909 r1946  
    277277    /// should be the dimension number of the graph.
    278278    ///
    279     /// \code
     279    ///\code
    280280    /// const int DIM = 3;
    281281    /// HyperCubeGraph graph(DIM);
     
    287287    /// HyperCubeGraph::HyperMap<xy<double> >
    288288    ///   pos(graph, base, base + DIM, xy<double>(0.0, 0.0));
    289     /// \endcode
     289    ///\endcode
    290290    ///
    291291    /// \see HyperCubeGraph
  • lemon/johnson.h

    r1916 r1946  
    609609    ///
    610610    /// \note d.run(s) is just a shortcut of the following code.
    611     /// \code
     611    ///\code
    612612    ///  d.init();
    613613    ///  d.start();
    614     /// \endcode
     614    ///\endcode
    615615    void run() {
    616616      init();
  • lemon/kruskal.h

    r1942 r1946  
    7878  /// say 53 edges, then
    7979  /// we can put its edges into a STL vector \c tree with a code like this.
    80   /// \code
     80  ///\code
    8181  /// std::vector<Edge> tree(53);
    8282  /// kruskal(g,cost,tree.begin());
    83   /// \endcode
     83  ///\endcode
    8484  /// Or if we don't know in advance the size of the tree, we can write this.
    85   /// \code
     85  ///\code
    8686  /// std::vector<Edge> tree;
    8787  /// kruskal(g,cost,std::back_inserter(tree));
    88   /// \endcode
     88  ///\endcode
    8989  ///
    9090  /// \return The cost of the found tree.
     
    301301  ///
    302302  /// A typical usage:
    303   /// \code
     303  ///\code
    304304  /// std::vector<Graph::Edge> v;
    305305  /// kruskal(g, input, makeKruskalSequenceOutput(back_inserter(v)));
    306   /// \endcode
     306  ///\endcode
    307307  ///
    308308  /// For the most common case, when the input is given by a simple edge
     
    397397//   say 53 edges, then
    398398//   we can put its edges into a STL vector \c tree with a code like this.
    399 //   \code
     399//\code
    400400//   std::vector<Edge> tree(53);
    401401//   kruskal(g,cost,tree.begin());
    402 //   \endcode
     402//\endcode
    403403//   Or if we don't know in advance the size of the tree, we can write this.
    404 //   \code
     404//\code
    405405//   std::vector<Edge> tree;
    406406//   kruskal(g,cost,std::back_inserter(tree));
    407 //   \endcode
     407//\endcode
    408408// 
    409409//   \return The cost of the found tree.
  • lemon/lemon_reader.h

    r1909 r1946  
    19631963  /// to know which sections, maps and items are in the file
    19641964  /// use the next code:
    1965   /// \code
     1965  ///\code
    19661966  /// LemonReader reader("input.lgf");
    19671967  /// ContentReader content(reader);
    19681968  /// reader.run();
    1969   /// \endcode
     1969  ///\endcode
    19701970  class ContentReader : public LemonReader::SectionReader {
    19711971    typedef LemonReader::SectionReader Parent;
Note: See TracChangeset for help on using the changeset viewer.