COIN-OR::LEMON - Graph Library

Changeset 911:89a4fbb99cad in lemon-0.x


Ignore:
Timestamp:
09/28/04 09:00:58 (16 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1222
Message:

Fix many doxygen command bugs.

Files:
11 edited

Legend:

Unmodified
Added
Removed
  • doc/graphs.dox

    r880 r911  
    2929The implemented graph structures are the following.
    3030\li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
    31 the hugo::skeleton::ErasableGraph "ErasableGraph" concept
     31the \ref hugo::skeleton::ErasableGraph "ErasableGraph" concept
    3232and it also have some convenience features.
    3333\li \ref hugo::SmartGraph "SmartGraph" is a more memory
     
    4646are shared by the edge pairs.
    4747\li \ref hugo::FullGraph "FullGraph"
    48 implements a full graph. It is a \ref ConstGraph, so you cannot
     48implements a full graph. It is a \ref hugo::skeleton::StaticGraph, so you cannot
    4949change the number of nodes once it is constructed. It is extremely memory
    5050efficient: it uses constant amount of memory independently from the number of
  • src/hugo/bfs.h

    r906 r911  
    5050    ///The type of the underlying graph.
    5151    typedef GR Graph;
    52     ///.
     52    ///\e
    5353    typedef typename Graph::Node Node;
    54     ///.
     54    ///\e
    5555    typedef typename Graph::NodeIt NodeIt;
    56     ///.
     56    ///\e
    5757    typedef typename Graph::Edge Edge;
    58     ///.
     58    ///\e
    5959    typedef typename Graph::OutEdgeIt OutEdgeIt;
    6060   
     
    109109   
    110110    ///\param _G the graph the algorithm will run on.
     111    ///
    111112    Bfs(const Graph& _G) :
    112113      G(&_G),
  • src/hugo/dfs.h

    r906 r911  
    4949    ///The type of the underlying graph.
    5050    typedef GR Graph;
    51     /// .
     51    ///\e
    5252    typedef typename Graph::Node Node;
    53     /// .
     53    ///\e
    5454    typedef typename Graph::NodeIt NodeIt;
    55     /// .
     55    ///\e
    5656    typedef typename Graph::Edge Edge;
    57     /// .
     57    ///\e
    5858    typedef typename Graph::OutEdgeIt OutEdgeIt;
    5959   
     
    108108   
    109109    ///\param _G the graph the algorithm will run on.
     110    ///
    110111    Dfs(const Graph& _G) :
    111112      G(&_G),
  • src/hugo/dijkstra.h

    r906 r911  
    7272    ///The type of the underlying graph.
    7373    typedef GR Graph;
    74     ///.
     74    ///\e
    7575    typedef typename Graph::Node Node;
    76     ///.
     76    ///\e
    7777    typedef typename Graph::NodeIt NodeIt;
    78     ///.
     78    ///\e
    7979    typedef typename Graph::Edge Edge;
    80     ///.
     80    ///\e
    8181    typedef typename Graph::OutEdgeIt OutEdgeIt;
    8282   
  • src/hugo/fib_heap.h

    r906 r911  
    3636  ///is a data structure for storing items with specified values called \e
    3737  ///priorities in such a way that finding the item with minimum priority is
    38   ///efficient. \ref Compare specifies the ordering of the priorities. In a heap
     38  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
    3939  ///one can change the priority of an item, add or erase an item, etc.
    4040  ///
     
    118118    void push (Item const item, PrioType const value);
    119119   
    120     ///Returns the item with minimum priority relative to \ref Compare.
    121    
    122     /**
    123        This method returns the item with minimum priority relative to \ref
     120    ///Returns the item with minimum priority relative to \c Compare.
     121   
     122    /**
     123       This method returns the item with minimum priority relative to \c
    124124       Compare. 
    125125       \pre The heap must be nonempty. 
     
    127127    Item top() const { return container[minimum].name; }
    128128
    129     ///Returns the minimum priority relative to \ref Compare.
    130 
    131     /**
    132        It returns the minimum priority relative to \ref Compare.
     129    ///Returns the minimum priority relative to \c Compare.
     130
     131    /**
     132       It returns the minimum priority relative to \c Compare.
    133133       \pre The heap must be nonempty.
    134134    */
     
    156156
    157157
    158     ///Deletes the item with minimum priority relative to \ref Compare.
    159 
    160     /**
    161     This method deletes the item with minimum priority relative to \ref
     158    ///Deletes the item with minimum priority relative to \c Compare.
     159
     160    /**
     161    This method deletes the item with minimum priority relative to \c
    162162    Compare from the heap. 
    163163    \pre The heap must be non-empty. 
     
    178178       This method decreases the priority of \c item to \c value.
    179179       \pre \c item must be stored in the heap with priority at least \c
    180        value relative to \ref Compare.
     180       value relative to \c Compare.
    181181    */
    182182    void decrease (Item item, PrioType const value);
     
    188188       there is no precondition on the priority of \c item, this
    189189       method should be used only if it is indeed necessary to increase
    190        (relative to \ref Compare) the priority of \c item, because this
     190       (relative to \c Compare) the priority of \c item, because this
    191191       method is inefficient.
    192192    */
  • src/hugo/graph_wrapper.h

    r910 r911  
    606606  /// bidirected graph made from a directed one.
    607607  ///
     608  /// A wrapper for composing a subgraph of a
     609  /// bidirected graph made from a directed one.
     610  ///
    608611  ///\warning Graph wrappers are in even more experimental state than the other
    609612  ///parts of the lib. Use them at you own risk.
  • src/hugo/list_graph.h

    r909 r911  
    422422  ///of oppositely directed edges.
    423423  ///There is a new edge map type called
    424   ///\ref SymListGraph::SymEdgeMap "SymEdgeMap"
     424  ///\ref hugo::SymListGraph::SymEdgeMap "SymEdgeMap"
    425425  ///that complements this
    426426  ///feature by
    427427  ///storing shared values for the edge pairs. The usual
    428   ///\ref Graph::EdgeMap "EdgeMap"
     428  ///\ref hugo::skeleton::StaticGraph::EdgeMap "EdgeMap"
    429429  ///can be used
    430430  ///as well.
    431431  ///
    432432  ///The oppositely directed edge can also be obtained easily
    433   ///using \ref opposite.
     433  ///using \ref hugo::SymListGraph::opposite() "opposite()" member function.
    434434  ///
    435435  ///Here erase(Edge) deletes a pair of edges.
  • src/hugo/maps.h

    r906 r911  
    3636  {
    3737  public:
    38     /// .
     38    ///\e
    3939    typedef K KeyType;
    40     /// .
     40    ///\e
    4141    typedef T ValueType;
    4242  };
     
    7575    /// (More exactly it will be default constructed.)
    7676    ConstMap() {}
    77     /// .
     77    ///\e
    7878
    7979    /// \param _v The initial value of the map.
     80    ///
    8081    ConstMap(const T &_v) : v(_v) {}
    8182
  • src/hugo/preflow.h

    r906 r911  
    4545  ///setFlow.
    4646  ///
    47   ///After running \ref phase1() or \ref preflow(), the actual flow
     47  ///After running \ref hugo::Preflow::phase1() "phase1()"
     48  ///or \ref hugo::Preflow::run() "run()", the actual flow
    4849  ///value can be obtained by calling \ref flowValue(). The minimum
    4950  ///value cut can be written into a <tt>bool</tt> node map by
     
    9798    ///- \c PRE_FLOW: any preflow, i.e. the sum of the in-flows is at
    9899    ///least the sum of the out-flows in every node except the \e source.
    99     ///- \c NO_FLOW: indicates an unspecified edge map. \ref flow will be
    100     ///set to the constant zero flow in the beginning of the algorithm in this case.
     100    ///- \c NO_FLOW: indicates an unspecified edge map. \c flow will be
     101    ///set to the constant zero flow in the beginning of
     102    ///the algorithm in this case.
    101103    ///
    102104    enum FlowEnum{
     
    195197    ///minimum value cut can already be computed, though a maximum flow
    196198    ///is not yet obtained. So after calling this method \ref flowValue
    197     ///and \ref actMinCut gives proper results.
    198     ///\warning \ref minCut, \ref minMinCut and \ref maxMinCut do not
    199     ///give minimum value cuts unless calling \ref phase2.
     199    ///and \ref MinCut() gives proper results.
     200    ///\warning \ref minCut(), \ref minMinCut() and \ref maxMinCut() do not
     201    ///give minimum value cuts unless calling \ref phase2().
    200202    void phase1()
    201203    {
     
    350352
    351353    /// Returns the value of the maximum flow by returning the excess
    352     /// of the target node \ref t. This value equals to the value of
     354    /// of the target node \c t. This value equals to the value of
    353355    /// the maximum flow already after running \ref phase1.
    354356    Num flowValue() const {
     
    363365    ///phase1 and \ref phase2. It is much faster after
    364366    ///\ref phase1.  \pre M should be a bool-valued node-map. \pre
    365     ///If \ref mincut is called after \ref phase2 then M should
     367    ///If \ref minCut() is called after \ref phase2() then M should
    366368    ///be initialized to false.
    367369    template<typename _CutMap>
     
    426428    ///which is inclusionwise maximum. It is computed by processing a
    427429    ///backward bfs from the target node \c t in the residual graph.
    428     ///\pre \ref phase2() or preflow() should already be run.
     430    ///\pre \ref phase2() or run() should already be run.
    429431    template<typename _CutMap>
    430432    void maxMinCut(_CutMap& M) const {
  • src/hugo/skeletons/graph.h

    r906 r911  
    9393        /// Inequality operator
    9494       
    95         /// \sa \ref operator==(Node n)
     95        /// \sa operator==(Node n)
    9696        ///
    9797        bool operator!=(Node) const { return true; }
     
    181181        /// Inequality operator
    182182
    183         /// \sa \ref operator==(Node n)
     183        /// \sa operator==(Node n)
    184184        ///
    185185        bool operator!=(Edge) const { return true; }
     
    383383      int id(const Edge&) const { return 0; }
    384384
    385       /// .
     385      ///\e
    386386     
    387387      ///\todo Should it be in the concept?
    388388      ///
    389389      int nodeNum() const { return 0; }
    390       /// .
     390      ///\e
    391391
    392392      ///\todo Should it be in the concept?
     
    406406      public:
    407407
    408         /// .
     408        ///\e
    409409        NodeMap(const StaticGraph&) { }
    410         /// .
     410        ///\e
    411411        NodeMap(const StaticGraph&, T) { }
    412412
     
    430430      public:
    431431
    432         /// .
     432        ///\e
    433433        EdgeMap(const StaticGraph&) { }
    434         /// .
     434        ///\e
    435435        EdgeMap(const StaticGraph&, T) { }
    436436   
  • src/hugo/skeletons/sym_graph.h

    r909 r911  
    4646    /// feature, the documentation of a real symmetric graph imlementation
    4747    /// like @ref SymListGraph or
    48     /// @ref SymSmartGraph will just refer to this structure.
     48    /// @ref hugo::SymSmartGraph will just refer to this structure.
    4949    class StaticSymGraph
    5050    {
     
    9494        /// Inequality operator
    9595       
    96         /// \sa \ref operator==(Node n)
     96        /// \sa operator==(Node n)
    9797        ///
    9898        bool operator!=(Node) const { return true; }
     
    182182        /// Inequality operator
    183183
    184         /// \sa \ref operator==(Node n)
     184        /// \sa operator==(Node n)
    185185        ///
    186186        bool operator!=(SymEdge) const { return true; }
     
    224224        /// Inequality operator
    225225
    226         /// \sa \ref operator==(Node n)
     226        /// \sa operator==(Node n)
    227227        ///
    228228        bool operator!=(Edge) const { return true; }
     
    490490      int id(const SymEdge&) const { return 0; }
    491491
    492       /// .
     492      ///\e
    493493     
    494494      ///\todo Should it be in the concept?
    495495      ///
    496496      int nodeNum() const { return 0; }
    497       /// .
     497      ///\e
    498498
    499499      ///\todo Should it be in the concept?
     
    525525      public:
    526526
    527         /// .
     527        ///\e
    528528        NodeMap(const StaticSymGraph&) { }
    529         /// .
     529        ///\e
    530530        NodeMap(const StaticSymGraph&, T) { }
    531531
     
    549549      public:
    550550
    551         /// .
     551        ///\e
    552552        EdgeMap(const StaticSymGraph&) { }
    553         /// .
     553        ///\e
    554554        EdgeMap(const StaticSymGraph&, T) { }
    555555   
     
    573573      public:
    574574
    575         /// .
     575        ///\e
    576576        SymEdgeMap(const StaticSymGraph&) { }
    577         /// .
     577        ///\e
    578578        SymEdgeMap(const StaticSymGraph&, T) { }
    579579   
Note: See TracChangeset for help on using the changeset viewer.