COIN-OR::LEMON - Graph Library

Changeset 851:209c9d53e195 in lemon-0.x


Ignore:
Timestamp:
09/14/04 12:29:47 (15 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1150
Message:

Changes in doc.

Location:
src/hugo
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • src/hugo/minlengthpaths.h

    r788 r851  
    6767    ///Runs the algorithm.
    6868    ///Returns k if there are at least k edge-disjoint paths from s to t.
    69    ///Otherwise it returns the number of found edge-disjoint paths from s to t.
     69    ///Otherwise it returns the number of found edge-disjoint paths from s to t.
    7070    int run(Node s, Node t, int k) {
    7171
     
    112112
    113113   
     114    ///Total length of the paths
     115   
    114116    ///This function gives back the total length of the found paths.
    115     ///Assumes that \c run() has been run and nothing changed since then.
     117    ///\pre \ref run() must
     118    ///be called before using this function.
    116119    Length totalLength(){
    117120      return mincost_flow.totalLength();
    118121    }
    119122
    120     ///Returns a const reference to the EdgeMap \c flow. \pre \ref run() must
     123    ///Return the found flow.
     124
     125    ///This function returns a const reference to the EdgeMap \c flow.
     126    ///\pre \ref run() must
    121127    ///be called before using this function.
    122128    const EdgeIntMap &getFlow() const { return mincost_flow.flow;}
    123129
    124   ///Returns a const reference to the NodeMap \c potential (the dual solution).
     130    /// Return the optimal dual solution
     131   
     132    ///This function returns a const reference to the NodeMap
     133    ///\c potential (the dual solution).
    125134    /// \pre \ref run() must be called before using this function.
    126135    const EdgeIntMap &getPotential() const { return mincost_flow.potential;}
    127136
     137    ///Checks whether the complementary slackness holds.
     138
    128139    ///This function checks, whether the given solution is optimal
    129140    ///Running after a \c run() should return with true
    130     ///In this "state of the art" this only checks optimality, doesn't bother with feasibility
     141    ///Currently this function only checks optimality,
     142    ///doesn't bother with feasibility
    131143    ///
    132144    ///\todo Is this OK here?
     
    135147    }
    136148
     149    ///Read the found paths.
     150   
    137151    ///This function gives back the \c j-th path in argument p.
    138152    ///Assumes that \c run() has been run and nothing changed since then.
    139     /// \warning It is assumed that \c p is constructed to be a path of graph \c G. If \c j is not less than the result of previous \c run, then the result here will be an empty path (\c j can be 0 as well).
    140     template<typename DirPath>
    141     void getPath(DirPath& p, size_t j){
     153    /// \warning It is assumed that \c p is constructed to
     154    ///be a path of graph \c G.
     155    ///If \c j is not less than the result of previous \c run,
     156    ///then the result here will be an empty path (\c j can be 0 as well).
     157    template<typename Path>
     158    void getPath(Path& p, size_t j){
    142159     
    143160      p.clear();
  • src/hugo/preflow.h

    r849 r851  
    1717  /// @{                                                   
    1818
    19   ///Preflow algorithms class.
     19  ///%Preflow algorithms class.
    2020
    2121  ///This class provides an implementation of the \e preflow \e
    2222  ///algorithm producing a flow of maximum value in a directed
    2323  ///graph. The preflow algorithms are the fastest max flow algorithms
    24   ///up-to-date. The \e source node, the \e target node, the \e
     24  ///up to now. The \e source node, the \e target node, the \e
    2525  ///capacity of the edges and the \e starting \e flow value of the
    2626  ///edges should be passed to the algorithm through the
     
    2929  ///setFlow.
    3030  ///
    31   ///After running \c phase1 or \c preflow, the actual flow
     31  ///After running \ref phase1() or \ref preflow(), the actual flow
    3232  ///value can be obtained by calling \ref flowValue(). The minimum
    33   ///value cut can be written into a \c node map of \c bools by
    34   ///calling \ref minCut. (\ref minMinCut and \ref maxMinCut writes
     33  ///value cut can be written into a <tt>bool</tt> node map by
     34  ///calling \ref minCut(). (\ref minMinCut() and \ref maxMinCut() writes
    3535  ///the inclusionwise minimum and maximum of the minimum value cuts,
    3636  ///resp.)
     
    130130    ///Runs the preflow algorithm. 
    131131
    132     ///Runs the preflow algorithm.
     132    ///Runs the preflow algorithm.
     133    ///
    133134    void run() {
    134135      phase1(flow_prop);
     
    158159    ///is not yet obtained. So after calling this method \ref flowValue
    159160    ///and \ref minCut gives proper results.
    160     ///\warning: \ref minMinCut and \ref maxMinCut do not
     161    ///\warning \ref minMinCut and \ref maxMinCut do not
    161162    ///give minimum value cuts unless calling \ref phase2.
    162163    ///\pre The starting flow must be
     
    179180    ///is not yet obtained. So after calling this method \ref flowValue
    180181    ///and \ref actMinCut gives proper results.
    181     ///\warning: \ref minCut, \ref minMinCut and \ref maxMinCut do not
     182    ///\warning \ref minCut, \ref minMinCut and \ref maxMinCut do not
    182183    ///give minimum value cuts unless calling \ref phase2.
    183184    void phase1()
Note: See TracChangeset for help on using the changeset viewer.