COIN-OR::LEMON - Graph Library

Changeset 2476:059dcdda37c5 in lemon-0.x


Ignore:
Timestamp:
09/27/07 15:04:06 (12 years ago)
Author:
Peter Kovacs
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3315
Message:

Bug fixes in the documentation (mainly bad references).

Files:
12 edited

Legend:

Unmodified
Added
Removed
  • demo/eps_demo.cc

    r2391 r2476  
    1919/// \ingroup demos
    2020/// \file
    21 /// \brief Demo of the EPS grawing class \ref EpsDrawer()
     21/// \brief Demo of the EPS grawing class \ref lemon::EpsDrawer "EpsDrawer".
    2222///
    2323/// This demo program shows examples how to use the class \ref
    24 /// EpsDrawer(). It takes no input but simply creates a file
    25 /// <tt>eps_demo.eps</tt> demonstrating the capability of \ref
    26 /// EpsDrawer().
     24/// lemon::EpsDrawer "EpsDrawer". It takes no input but simply creates
     25/// a file <tt>eps_demo.eps</tt> demonstrating the capability of \ref
     26/// lemon::EpsDrawer "EpsDrawer".
    2727///
    2828/// \include eps_demo.cc
  • doc/algorithms.dox

    r2470 r2476  
    115115\skip MyOrdererMap
    116116\until };
    117 The class meets the \ref lemon::WriteMap "WriteMap" concept. In it's \c set() method the only thing
     117The class meets the \ref concepts::WriteMap "WriteMap" concept. In it's \c set() method the only thing
    118118we need to do is insert the key - that is the node whose processing just finished - into the beginning
    119119of the list.<br>
  • doc/basic_concepts.dox

    r2391 r2476  
    3030have to satisfy one or more \ref concept "graph concepts" which are standardized
    3131interfaces to work with the rest of the library. The most basic concept is the
    32 \ref Graph.<br>
     32\ref concepts::Graph "Graph".<br>
    3333A good example is the \ref ListGraph which we already know from Hello World and
    3434will be used in our examples as well.
     
    4848to the graph with the addNode() member function. It returns the newly added node
    4949(as value). So if you need the new node to do something useful with, for example
    50 create an edge, assign a value to it through \ref map1 maps.
     50create an edge, assign a value to it through \ref maps1 maps.
    5151\code lemon::ListGraph::Node  new_node = graph.addNode(); \endcode
    5252
     
    115115the next page.)
    116116
    117 The \ref EdgeIt works exactly the same - nothing more to say. But there are \ref InEdgeIt
    118 and \ref OutEdgeIt by directed graphs and \ref IncEdgeIt by undirected graphs.
     117The \ref concepts::Graph::EdgeIt "EdgeIt" works exactly the same - nothing more to say.
     118But there are \ref concepts::Graph::InEdgeIt "InEdgeIt" and
     119\ref concepts::Graph::OutEdgeIt "OutEdgeIt" by directed graphs and
     120\ref concepts::UGraph::IncEdgeIt "IncEdgeIt" by undirected graphs.
    119121They take two arguments. The first is a graph, the second is certain node of the
    120122graph. InEdgeIt iterates on the incoming edges of that node and OutEdgeIt does it
  • doc/graphs.dox

    r2391 r2476  
    1717 */
    1818
     19namespace lemon {
     20
    1921/*!
    20 
    2122\page graphs Graphs
    2223
     
    3031as  incoming and outgoing edges of a given node.
    3132
    32 Each graph should meet the \ref lemon::concepts::Graph "Graph" concept.
     33Each graph should meet the \ref concepts::Graph "Graph" concept.
    3334This concept does not make it possible to change the graph (i.e. it is
    3435not possible to add or delete edges or nodes). Most of the graph
     
    3738
    3839In case of graphs meeting the full feature
    39 \ref lemon::concepts::ErasableGraph "ErasableGraph"
    40 concept
     40\ref concepts::ErasableGraph "ErasableGraph" concept
    4141you can also erase individual edges and nodes in arbitrary order.
    4242
    4343The implemented graph structures are the following.
    44 \li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
    45 the \ref lemon::concepts::ErasableGraph "ErasableGraph" concept
     44\li \ref ListGraph is the most versatile graph class. It meets
     45the \ref concepts::ErasableGraph "ErasableGraph" concept
    4646and it also has some convenient extra features.
    47 \li \ref lemon::SmartGraph "SmartGraph" is a more memory
    48 efficient version of \ref lemon::ListGraph "ListGraph". The
    49 price of this is that it only meets the
    50 \ref lemon::concepts::ExtendableGraph "ExtendableGraph" concept,
     47\li \ref SmartGraph is a more memory efficient version of \ref ListGraph.
     48The price of this is that it only meets the
     49\ref concepts::ExtendableGraph "ExtendableGraph" concept,
    5150so you cannot delete individual edges or nodes.
    52 \li \ref lemon::FullGraph "FullGraph"
     51\li \ref FullGraph "FullGraph"
    5352implements a complete graph. It is a
    54 \ref lemon::concepts::Graph "Graph", so you cannot
     53\ref concepts::Graph "Graph", so you cannot
    5554change the number of nodes once it is constructed. It is extremely memory
    5655efficient: it uses constant amount of memory independently from the number of
     
    5857\ref maps-page "EdgeMap"'s will depend on the number of nodes.
    5958
    60 \li \ref lemon::NodeSet "NodeSet" implements a graph with no edges. This class
     59\li \ref NodeSet "NodeSet" implements a graph with no edges. This class
    6160can be used as a base class of \ref lemon::EdgeSet "EdgeSet".
    62 \li \ref lemon::EdgeSet "EdgeSet" can be used to create a new graph on
     61\li \ref EdgeSet "EdgeSet" can be used to create a new graph on
    6362the node set of another graph. The base graph can be an arbitrary graph and it
    64 is possible to attach several \ref lemon::EdgeSet "EdgeSet"'s to a base graph.
     63is possible to attach several \ref EdgeSet "EdgeSet"'s to a base graph.
    6564
    6665\todo Don't we need SmartNodeSet and SmartEdgeSet?
     
    121120step to the next node. Using operator++ on the iterator pointing to the last
    122121node invalidates the iterator i.e. sets its value to
    123 \ref lemon::INVALID "INVALID". This is what we exploit in the stop condition.
     122\ref INVALID. This is what we exploit in the stop condition.
    124123
    125124The previous code fragment prints out the following:
     
    201200
    202201*/
     202
     203}
     204
  • doc/maps1.dox

    r2408 r2476  
    1616 *
    1717 */
     18
     19namespace lemon {
    1820
    1921/**
     
    3537To make easy to use them - especially as template parameters - there are <i>map concepts</i> like by graph classes.
    3638<ul>
    37 <li>\ref ReadMap - values can be read out with the \c operator[].
     39<li>\ref concepts::ReadMap "ReadMap" - values can be read out with the \c operator[].
    3840\code value_typed_variable = map_instance[key_value]; \endcode
    3941</li>
    40 <li>\ref WriteMap - values can be set with the \c set() member function.
     42<li>\ref concepts::WriteMap "WriteMap" - values can be set with the \c set() member function.
    4143\code map_instance.set(key_value, value_typed_expression); \endcode
    4244</li>
    43 <li>\ref ReadWriteMap - it's just a shortcut to indicate that the map is both
     45<li>\ref concepts::ReadWriteMap "ReadWriteMap" - it's just a shortcut to indicate that the map is both
    4446readable and writable. It is delivered from them.
    4547</li>
    46 <li>\ref ReferenceMap - a subclass of ReadWriteMap. It has two additional typedefs
     48<li>\ref concepts::ReferenceMap "ReferenceMap" - a subclass of ReadWriteMap. It has two additional typedefs
    4749<i>Reference</i> and <i>ConstReference</i> and two overloads of \c operator[] to
    4850providing you constant or non-constant reference to the value belonging to a key,
     
    5052</li>
    5153<li>And there are the Matrix version of these maps, where the values are assigned to a pair of keys.
    52 The keys can be different types. (\ref ReadMatrixMap, \ref WriteMatrixMap, \ref ReadWriteMatrixMap, \ref ReferenceMatrixMap)
     54The keys can be different types. (\ref concepts::ReadMatrixMap "ReadMatrixMap",
     55\ref concepts::WriteMatrixMap "WriteMatrixMap", \ref concepts::ReadWriteMatrixMap "ReadWriteMatrixMap",
     56\ref concepts::ReferenceMatrixMap "ReferenceMatrixMap")
    5357</li>
    5458</ul>
     
    8993Or if you want to know more about maps read these \ref maps2 "advanced map techniques".
    9094*/
     95
     96}
  • lemon/bellman_ford.h

    r2408 r2476  
    433433    /// easily with \ref path() or \ref predEdge() functions. If you
    434434    /// need the shortest path and not just the distance you should store
    435     /// after each iteration the \ref predEdgeMap() map and manually build
     435    /// after each iteration the \ref predMap() map and manually build
    436436    /// the path.
    437437    ///
     
    546546    /// easily with \ref path() or \ref predEdge() functions. If you
    547547    /// need the shortest path and not just the distance you should store
    548     /// after each iteration the \ref predEdgeMap() map and manually build
     548    /// after each iteration the \ref predMap() map and manually build
    549549    /// the path.
    550550    ///
     
    952952    ///
    953953    /// Runs BellmanFord algorithm from the given node.
    954     /// \param source is the given source.
     954    /// \param src is the given source.
    955955    void run(Node src) {
    956956      Base::_source = src;
     
    10171017    ///
    10181018    /// Sets the source node, from which the BellmanFord algorithm runs.
    1019     /// \param source is the source node.
     1019    /// \param src is the source node.
    10201020    BellmanFordWizard<_Traits>& source(Node src) {
    10211021      Base::_source = src;
  • lemon/bfs.h

    r2443 r2476  
    594594    ///
    595595    ///This method runs the %BFS algorithm from the root node(s)
    596     ///in order to
    597     ///compute the
    598     ///shortest path to \c dest. The algorithm computes
     596    ///in order to compute the shortest path to \c dest.
     597    ///The algorithm computes
    599598    ///- The shortest path to \c  dest.
    600599    ///- The distance of \c dest from the root(s).
     
    616615    /// <tt>nm[v]</tt> true.
    617616    ///
    618     ///\return The reached node \c v with <tt>nm[v]<\tt> true or
     617    ///\return The reached node \c v with <tt>nm[v]</tt> true or
    619618    ///\c INVALID if no such node was found.
    620619    template<class NM>
     
    15181517    /// <tt>nm[v]</tt> true.
    15191518    ///
    1520     ///\return The reached node \c v with <tt>nm[v]<\tt> true or
     1519    ///\return The reached node \c v with <tt>nm[v]</tt> true or
    15211520    ///\c INVALID if no such node was found.
    15221521    template <typename NM>
  • lemon/dfs.h

    r2443 r2476  
    565565    ///
    566566    ///\param em must be a bool (or convertible) edge map. The algorithm
    567     ///will stop when it reaches an edge \c e with <tt>em[e]<\tt> true.
    568     ///
    569     ///\return The reached edge \c e with <tt>em[e]<\tt> true or
     567    ///will stop when it reaches an edge \c e with <tt>em[e]</tt> true.
     568    ///
     569    ///\return The reached edge \c e with <tt>em[e]</tt> true or
    570570    ///\c INVALID if no such edge was found.
    571571    ///
     
    14591459    ///
    14601460    /// \param em must be a bool (or convertible) edge map. The algorithm
    1461     /// will stop when it reaches an edge \c e with <tt>em[e]<\tt> true.
    1462     ///
    1463     ///\return The reached edge \c e with <tt>em[e]<\tt> true or
     1461    /// will stop when it reaches an edge \c e with <tt>em[e]</tt> true.
     1462    ///
     1463    ///\return The reached edge \c e with <tt>em[e]</tt> true or
    14641464    ///\c INVALID if no such edge was found.
    14651465    ///
  • lemon/dijkstra.h

    r2443 r2476  
    666666    ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
    667667    ///
    668     ///\return The reached node \c v with <tt>nm[v]<\tt> true or
     668    ///\return The reached node \c v with <tt>nm[v]</tt> true or
    669669    ///\c INVALID if no such node was found.
    670670    template<class NodeBoolMap>
  • lemon/error.h

    r2410 r2476  
    635635/// behaviour will be activated. The \c msg should be either a const
    636636/// char* message or an exception. When the \c msg is an exception the
    637 /// \ref "Exception::what" what() function is called to retrieve and
     637/// \ref lemon::Exception::what() "what()" function is called to retrieve and
    638638/// display the error message.
    639639///
  • lemon/graph_utils.h

    r2474 r2476  
    373373  ///
    374374  ///\sa EdgeLookUp
    375   ///\se AllEdgeLookUp
     375  ///\sa AllEdgeLookUp
    376376  ///\sa ConEdgeIt
    377377  template <typename Graph>
  • lemon/lemon_reader.h

    r2467 r2476  
    11291129    /// It gives back true when the header line starts with \c \@edgeset,
    11301130    /// and the header line's name and the edgeset's name are the same.
    1131     /// The sections with @uedgeset head line could be read with this
     1131    /// The sections with \@uedgeset head line could be read with this
    11321132    /// section reader too.
    11331133    virtual bool header(const std::string& line) {
     
    14381438    /// It gives back true when the header line starts with \c \@uedgeset,
    14391439    /// and the header line's name and the edgeset's name are the same.
    1440     /// The sections with @edgeset head line could be read with this
     1440    /// The sections with \@edgeset head line could be read with this
    14411441    /// section reader too.
    14421442    virtual bool header(const std::string& line) {
Note: See TracChangeset for help on using the changeset viewer.