COIN-OR::LEMON - Graph Library

Changeset 786:e20173729589 in lemon-1.2 for lemon


Ignore:
Timestamp:
11/13/09 18:10:06 (10 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Small doc fixes in several files (#331)

Location:
lemon
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • lemon/bellman_ford.h

    r699 r786  
    300300    /// \ref named-templ-param "Named parameter" for setting
    301301    /// \c OperationTraits type.
    302     /// For more information see \ref BellmanFordDefaultOperationTraits.
     302    /// For more information, see \ref BellmanFordDefaultOperationTraits.
    303303    template <class T>
    304304    struct SetOperationTraits
     
    718718    ///
    719719    /// The shortest path tree used here is equal to the shortest path
    720     /// tree used in \ref predNode() and \predMap().
     720    /// tree used in \ref predNode() and \ref predMap().
    721721    ///
    722722    /// \pre Either \ref run() or \ref init() must be called before
     
    733733    ///
    734734    /// The shortest path tree used here is equal to the shortest path
    735     /// tree used in \ref predArc() and \predMap().
     735    /// tree used in \ref predArc() and \ref predMap().
    736736    ///
    737737    /// \pre Either \ref run() or \ref init() must be called before
  • lemon/bfs.h

    r717 r786  
    6464    ///The type of the map that indicates which nodes are processed.
    6565    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    66     ///By default it is a NullMap.
     66    ///By default, it is a NullMap.
    6767    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6868    ///Instantiates a \c ProcessedMap.
     
    853853    ///The type of the map that indicates which nodes are processed.
    854854    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    855     ///By default it is a NullMap.
     855    ///By default, it is a NullMap.
    856856    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    857857    ///Instantiates a ProcessedMap.
  • lemon/circulation.h

    r715 r786  
    307307    /// able to automatically created by the algorithm (i.e. the
    308308    /// digraph and the maximum level should be passed to it).
    309     /// However an external elevator object could also be passed to the
     309    /// However, an external elevator object could also be passed to the
    310310    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
    311311    /// before calling \ref run() or \ref init().
  • lemon/concepts/digraph.h

    r734 r786  
    108108
    109109      /// This iterator goes through each node of the digraph.
    110       /// Its usage is quite simple, for example you can count the number
     110      /// Its usage is quite simple, for example, you can count the number
    111111      /// of nodes in a digraph \c g of type \c %Digraph like this:
    112112      ///\code
     
    197197      /// This iterator goes trough the \e outgoing arcs of a certain node
    198198      /// of a digraph.
    199       /// 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
    200200      /// of outgoing arcs of a node \c n
    201201      /// in a digraph \c g of type \c %Digraph as follows.
     
    242242      /// This iterator goes trough the \e incoming arcs of a certain node
    243243      /// of a digraph.
    244       /// Its usage is quite simple, for example you can count the number
     244      /// Its usage is quite simple, for example, you can count the number
    245245      /// of incoming arcs of a node \c n
    246246      /// in a digraph \c g of type \c %Digraph as follows.
     
    286286
    287287      /// This iterator goes through each arc of the digraph.
    288       /// Its usage is quite simple, for example you can count the number
     288      /// Its usage is quite simple, for example, you can count the number
    289289      /// of arcs in a digraph \c g of type \c %Digraph as follows:
    290290      ///\code
  • lemon/concepts/graph.h

    r734 r786  
    141141
    142142      /// This iterator goes through each node of the graph.
    143       /// Its usage is quite simple, for example you can count the number
     143      /// Its usage is quite simple, for example, you can count the number
    144144      /// of nodes in a graph \c g of type \c %Graph like this:
    145145      ///\code
     
    229229
    230230      /// This iterator goes through each edge of the graph.
    231       /// Its usage is quite simple, for example you can count the number
     231      /// Its usage is quite simple, for example, you can count the number
    232232      /// of edges in a graph \c g of type \c %Graph as follows:
    233233      ///\code
     
    273273      /// This iterator goes trough the incident undirected edges
    274274      /// of a certain node of a graph.
    275       /// Its usage is quite simple, for example you can compute the
     275      /// Its usage is quite simple, for example, you can compute the
    276276      /// degree (i.e. the number of incident edges) of a node \c n
    277277      /// in a graph \c g of type \c %Graph as follows.
     
    370370
    371371      /// This iterator goes through each directed arc of the graph.
    372       /// Its usage is quite simple, for example you can count the number
     372      /// Its usage is quite simple, for example, you can count the number
    373373      /// of arcs in a graph \c g of type \c %Graph as follows:
    374374      ///\code
     
    414414      /// This iterator goes trough the \e outgoing directed arcs of a
    415415      /// certain node of a graph.
    416       /// Its usage is quite simple, for example you can count the number
     416      /// Its usage is quite simple, for example, you can count the number
    417417      /// of outgoing arcs of a node \c n
    418418      /// in a graph \c g of type \c %Graph as follows.
     
    462462      /// This iterator goes trough the \e incoming directed arcs of a
    463463      /// certain node of a graph.
    464       /// Its usage is quite simple, for example you can count the number
     464      /// Its usage is quite simple, for example, you can count the number
    465465      /// of incoming arcs of a node \c n
    466466      /// in a graph \c g of type \c %Graph as follows.
     
    588588      /// Returns the first node of the given edge.
    589589      ///
    590       /// Edges don't have source and target nodes, however methods
     590      /// Edges don't have source and target nodes, however, methods
    591591      /// u() and v() are used to query the two end-nodes of an edge.
    592592      /// The orientation of an edge that arises this way is called
     
    601601      /// Returns the second node of the given edge.
    602602      ///
    603       /// Edges don't have source and target nodes, however methods
     603      /// Edges don't have source and target nodes, however, methods
    604604      /// u() and v() are used to query the two end-nodes of an edge.
    605605      /// The orientation of an edge that arises this way is called
  • lemon/concepts/graph_components.h

    r734 r786  
    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
  • lemon/counter.h

    r440 r786  
    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/dfs.h

    r717 r786  
    6464    ///The type of the map that indicates which nodes are processed.
    6565    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    66     ///By default it is a NullMap.
     66    ///By default, it is a NullMap.
    6767    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6868    ///Instantiates a \c ProcessedMap.
     
    783783    ///The type of the map that indicates which nodes are processed.
    784784    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    785     ///By default it is a NullMap.
     785    ///By default, it is a NullMap.
    786786    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    787787    ///Instantiates a ProcessedMap.
  • lemon/dijkstra.h

    r717 r786  
    133133    ///The type of the map that indicates which nodes are processed.
    134134    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    135     ///By default it is a NullMap.
     135    ///By default, it is a NullMap.
    136136    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    137137    ///Instantiates a \c ProcessedMap.
     
    427427    ///passed to the constructor of the cross reference and the cross
    428428    ///reference should be passed to the constructor of the heap).
    429     ///However external heap and cross reference objects could also be
     429    ///However, external heap and cross reference objects could also be
    430430    ///passed to the algorithm using the \ref heap() function before
    431431    ///calling \ref run(Node) "run()" or \ref init().
     
    448448    ///\ref named-templ-param "Named parameter" for setting
    449449    ///\c OperationTraits type.
    450     /// For more information see \ref DijkstraDefaultOperationTraits.
     450    /// For more information, see \ref DijkstraDefaultOperationTraits.
    451451    template <class T>
    452452    struct SetOperationTraits
     
    997997    ///The type of the map that indicates which nodes are processed.
    998998    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    999     ///By default it is a NullMap.
     999    ///By default, it is a NullMap.
    10001000    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    10011001    ///Instantiates a ProcessedMap.
  • lemon/gomory_hu.h

    r713 r786  
    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;
     
    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);
  • lemon/graph_to_eps.h

    r617 r786  
    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  ///
     
    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/hypercube_graph.h

    r737 r786  
    288288  /// differ only on one position in the binary form.
    289289  /// This class is completely static and it needs constant memory space.
    290   /// Thus you can neither add nor delete nodes or edges, however 
     290  /// Thus you can neither add nor delete nodes or edges, however,
    291291  /// the structure can be resized using resize().
    292292  ///
  • lemon/lgf_reader.h

    r599 r786  
    428428  ///\endcode
    429429  ///
    430   /// By default the reader uses the first section in the file of the
     430  /// By default, the reader uses the first section in the file of the
    431431  /// proper type. If a section has an optional name, then it can be
    432432  /// selected for reading by giving an optional name parameter to the
     
    22222222    /// whitespaces are trimmed from each processed string.
    22232223    ///
    2224     /// For example let's see a section, which contain several
     2224    /// For example, let's see a section, which contain several
    22252225    /// integers, which should be inserted into a vector.
    22262226    ///\code
  • lemon/list_graph.h

    r741 r786  
    392392    ///
    393393    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
    394     ///arc remain valid, however \c InArcIt iterators are invalidated.
     394    ///arc remain valid, but \c InArcIt iterators are invalidated.
    395395    ///
    396396    ///\warning This functionality cannot be used together with the Snapshot
     
    404404    ///
    405405    ///\note \c InArcIt iterators referencing the changed arc remain
    406     ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
     406    ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
    407407    ///
    408408    ///\warning This functionality cannot be used together with the Snapshot
     
    550550    /// reversing, contracting, splitting arcs or nodes) cannot be
    551551    /// restored. These events invalidate the snapshot.
    552     /// However the arcs and nodes that were added to the digraph after
     552    /// However, the arcs and nodes that were added to the digraph after
    553553    /// making the current snapshot can be removed without invalidating it.
    554554    class Snapshot {
     
    12681268    ///
    12691269    ///\note \c EdgeIt iterators referencing the changed edge remain
    1270     ///valid, however \c ArcIt iterators referencing the changed edge and
     1270    ///valid, but \c ArcIt iterators referencing the changed edge and
    12711271    ///all other iterators whose base node is the changed node are also
    12721272    ///invalidated.
     
    13521352    /// (e.g. changing the end-nodes of edges or contracting nodes)
    13531353    /// cannot be restored. These events invalidate the snapshot.
    1354     /// However the edges and nodes that were added to the graph after
     1354    /// However, the edges and nodes that were added to the graph after
    13551355    /// making the current snapshot can be removed without invalidating it.
    13561356    class Snapshot {
  • lemon/lp_base.h

    r746 r786  
    147147    ///Iterator for iterate over the columns of an LP problem
    148148
    149     /// Its usage is quite simple, for example you can count the number
     149    /// Its usage is quite simple, for example, you can count the number
    150150    /// of columns in an LP \c lp:
    151151    ///\code
     
    242242    ///Iterator for iterate over the rows of an LP problem
    243243
    244     /// Its usage is quite simple, for example you can count the number
     244    /// Its usage is quite simple, for example, you can count the number
    245245    /// of rows in an LP \c lp:
    246246    ///\code
  • lemon/maps.h

    r726 r786  
    231231  /// This map is essentially a wrapper for \c std::vector. It assigns
    232232  /// values to integer keys from the range <tt>[0..size-1]</tt>.
    233   /// It can be used with some data structures, for example
    234   /// \c UnionFind, \c BinHeap, when the used items are small
     233  /// It can be used together with some data structures, e.g.
     234  /// heap types and \c UnionFind, when the used items are small
    235235  /// integers. This map conforms to the \ref concepts::ReferenceMap
    236   /// "ReferenceMap" concept.
     236  /// "ReferenceMap" concept. 
    237237  ///
    238238  /// The simplest way of using this map is through the rangeMap()
     
    349349  /// The name of this type also refers to this important usage.
    350350  ///
    351   /// Apart form that this map can be used in many other cases since it
     351  /// Apart form that, this map can be used in many other cases since it
    352352  /// is based on \c std::map, which is a general associative container.
    353   /// However keep in mind that it is usually not as efficient as other
     353  /// However, keep in mind that it is usually not as efficient as other
    354354  /// maps.
    355355  ///
     
    17861786  /// The most important usage of it is storing certain nodes or arcs
    17871787  /// that were marked \c true by an algorithm.
    1788   /// For example it makes easier to store the nodes in the processing
     1788  /// For example, it makes easier to store the nodes in the processing
    17891789  /// order of Dfs algorithm, as the following examples show.
    17901790  /// \code
     
    18011801  ///
    18021802  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
    1803   /// it cannot be used when a readable map is needed, for example as
     1803  /// it cannot be used when a readable map is needed, for example, as
    18041804  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
    18051805  ///
     
    19231923  /// Otherwise consider to use \c IterableValueMap, which is more
    19241924  /// suitable and more efficient for such cases. It provides iterators
    1925   /// to traverse the items with the same associated value, however
     1925  /// to traverse the items with the same associated value, but
    19261926  /// it does not have \c InverseMap.
    19271927  ///
     
    34673467  /// may provide alternative ways to modify the digraph.
    34683468  /// The correct behavior of InDegMap is not guarantied if these additional
    3469   /// features are used. For example the functions
     3469  /// features are used. For example, the functions
    34703470  /// \ref ListDigraph::changeSource() "changeSource()",
    34713471  /// \ref ListDigraph::changeTarget() "changeTarget()" and
     
    35973597  /// may provide alternative ways to modify the digraph.
    35983598  /// The correct behavior of OutDegMap is not guarantied if these additional
    3599   /// features are used. For example the functions
     3599  /// features are used. For example, the functions
    36003600  /// \ref ListDigraph::changeSource() "changeSource()",
    36013601  /// \ref ListDigraph::changeTarget() "changeTarget()" and
  • lemon/network_simplex.h

    r730 r786  
    4949  /// in LEMON for the minimum cost flow problem.
    5050  /// Moreover it supports both directions of the supply/demand inequality
    51   /// constraints. For more information see \ref SupplyType.
     51  /// constraints. For more information, see \ref SupplyType.
    5252  ///
    5353  /// Most of the parameters of the problem (except for the digraph)
     
    5858  /// \tparam GR The digraph type the algorithm runs on.
    5959  /// \tparam V The value type used for flow amounts, capacity bounds
    60   /// and supply values in the algorithm. By default it is \c int.
     60  /// and supply values in the algorithm. By default, it is \c int.
    6161  /// \tparam C The value type used for costs and potentials in the
    62   /// algorithm. By default it is the same as \c V.
     62  /// algorithm. By default, it is the same as \c V.
    6363  ///
    6464  /// \warning Both value types must be signed and all input data must
     
    6767  /// \note %NetworkSimplex provides five different pivot rule
    6868  /// implementations, from which the most efficient one is used
    69   /// by default. For more information see \ref PivotRule.
     69  /// by default. For more information, see \ref PivotRule.
    7070  template <typename GR, typename V = int, typename C = V>
    7171  class NetworkSimplex
     
    123123    /// implementations that significantly affect the running time
    124124    /// of the algorithm.
    125     /// By default \ref BLOCK_SEARCH "Block Search" is used, which
     125    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
    126126    /// proved to be the most efficient and the most robust on various
    127127    /// test inputs according to our benchmark tests.
    128     /// However another pivot rule can be selected using the \ref run()
     128    /// However, another pivot rule can be selected using the \ref run()
    129129    /// function with the proper parameter.
    130130    enum PivotRule {
    131131
    132       /// The First Eligible pivot rule.
     132      /// The \e First \e Eligible pivot rule.
    133133      /// The next eligible arc is selected in a wraparound fashion
    134134      /// in every iteration.
    135135      FIRST_ELIGIBLE,
    136136
    137       /// The Best Eligible pivot rule.
     137      /// The \e Best \e Eligible pivot rule.
    138138      /// The best eligible arc is selected in every iteration.
    139139      BEST_ELIGIBLE,
    140140
    141       /// The Block Search pivot rule.
     141      /// The \e Block \e Search pivot rule.
    142142      /// A specified number of arcs are examined in every iteration
    143143      /// in a wraparound fashion and the best eligible arc is selected
     
    145145      BLOCK_SEARCH,
    146146
    147       /// The Candidate List pivot rule.
     147      /// The \e Candidate \e List pivot rule.
    148148      /// In a major iteration a candidate list is built from eligible arcs
    149149      /// in a wraparound fashion and in the following minor iterations
     
    151151      CANDIDATE_LIST,
    152152
    153       /// The Altering Candidate List pivot rule.
     153      /// The \e Altering \e Candidate \e List pivot rule.
    154154      /// It is a modified version of the Candidate List method.
    155155      /// It keeps only the several best eligible arcs from the former
     
    811811    /// type will be used.
    812812    ///
    813     /// For more information see \ref SupplyType.
     813    /// For more information, see \ref SupplyType.
    814814    ///
    815815    /// \return <tt>(*this)</tt>
     
    843843    /// \ref reset() is called, thus only the modified parameters
    844844    /// have to be set again. See \ref reset() for examples.
    845     /// However the underlying digraph must not be modified after this
     845    /// However, the underlying digraph must not be modified after this
    846846    /// class have been constructed, since it copies and extends the graph.
    847847    ///
    848848    /// \param pivot_rule The pivot rule that will be used during the
    849     /// algorithm. For more information see \ref PivotRule.
     849    /// algorithm. For more information, see \ref PivotRule.
    850850    ///
    851851    /// \return \c INFEASIBLE if no feasible flow exists,
     
    872872    /// used, all the parameters given before are kept for the next
    873873    /// \ref run() call.
    874     /// However the underlying digraph must not be modified after this
     874    /// However, the underlying digraph must not be modified after this
    875875    /// class have been constructed, since it copies and extends the graph.
    876876    ///
  • lemon/preflow.h

    r715 r786  
    265265    /// able to automatically created by the algorithm (i.e. the
    266266    /// digraph and the maximum level should be passed to it).
    267     /// However an external elevator object could also be passed to the
     267    /// However, an external elevator object could also be passed to the
    268268    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
    269269    /// before calling \ref run() or \ref init().
  • lemon/time_measure.h

    r584 r786  
    376376    ///This function returns the number of stop() exections that is
    377377    ///necessary to really stop the timer.
    378     ///For example the timer
     378    ///For example, the timer
    379379    ///is running if and only if the return value is \c true
    380380    ///(i.e. greater than
  • lemon/unionfind.h

    r559 r786  
    4444  /// This is a very simple but efficient implementation, providing
    4545  /// only four methods: join (union), find, insert and size.
    46   /// For more features see the \ref UnionFindEnum class.
     46  /// For more features, see the \ref UnionFindEnum class.
    4747  ///
    4848  /// It is primarily used in Kruskal algorithm for finding minimal
Note: See TracChangeset for help on using the changeset viewer.