lemon-0.x: comparison src/hugo/preflow.h

equal deleted inserted replaced

-:a2503a08d25b
+:1f170c57e1db
 ///edges should be passed to the algorithm through the
 ///constructor. It is possible to change these quantities using the
 ///functions \ref setSource, \ref setTarget, \ref setCap and \ref
 ///setFlow.
 ///
-///After running \ref phase1() or \ref preflow(), the actual flow
+///After running \ref hugo::Preflow::phase1() "phase1()"
+///or \ref hugo::Preflow::run() "run()", the actual flow
 ///value can be obtained by calling \ref flowValue(). The minimum
 ///value cut can be written into a <tt>bool</tt> node map by
 ///calling \ref minCut(). (\ref minMinCut() and \ref maxMinCut() writes
 ///the inclusionwise minimum and maximum of the minimum value cuts,
 ///resp.)
 ///- \c GEN_FLOW: any flow, i.e. the sum of the in-flows equals to
 ///the sum of the out-flows in every node except the \e source and
 ///the \e target.
 ///- \c PRE_FLOW: any preflow, i.e. the sum of the in-flows is at
 ///least the sum of the out-flows in every node except the \e source.
-///- \c NO_FLOW: indicates an unspecified edge map. \ref flow will be
+///- \c NO_FLOW: indicates an unspecified edge map. \c flow will be
-///set to the constant zero flow in the beginning of the algorithm in this case.
+///set to the constant zero flow in the beginning of
+///the algorithm in this case.
 ///
 enum FlowEnum{
 NO_FLOW,
 ZERO_FLOW,
 GEN_FLOW,
 ///The preflow algorithm consists of two phases, this method runs the
 ///first phase. After the first phase the maximum flow value and a
 ///minimum value cut can already be computed, though a maximum flow
 ///is not yet obtained. So after calling this method \ref flowValue
-///and \ref actMinCut gives proper results.
+///and \ref MinCut() gives proper results.
-///\warning \ref minCut, \ref minMinCut and \ref maxMinCut do not
+///\warning \ref minCut(), \ref minMinCut() and \ref maxMinCut() do not
-///give minimum value cuts unless calling \ref phase2.
+///give minimum value cuts unless calling \ref phase2().
 void phase1()
 {
 int heur0=(int)(H0*n);  //time while running 'bound decrease'
 int heur1=(int)(H1*n);  //time while running 'highest label'
 int heur=heur1;         //starting time interval (#of relabels)
 }
 /// Returns the value of the maximum flow.
 /// Returns the value of the maximum flow by returning the excess
-/// of the target node \ref t. This value equals to the value of
+/// of the target node \c t. This value equals to the value of
 /// the maximum flow already after running \ref phase1.
 Num flowValue() const {
 return excess[t];
 }
 ///Sets \c M to the characteristic vector of a minimum value
 ///cut. This method can be called both after running \ref
 ///phase1 and \ref phase2. It is much faster after
 ///\ref phase1.  \pre M should be a bool-valued node-map. \pre
-///If \ref mincut is called after \ref phase2 then M should
+///If \ref minCut() is called after \ref phase2() then M should
 ///be initialized to false.
 template<typename _CutMap>
 void minCut(_CutMap& M) const {
 switch ( status ) {
 	case AFTER_PREFLOW_PHASE_1:
 ///Returns the inclusionwise maximum of the minimum value cuts.
 ///Sets \c M to the characteristic vector of the minimum value cut
 ///which is inclusionwise maximum. It is computed by processing a
 ///backward bfs from the target node \c t in the residual graph.
-///\pre \ref phase2() or preflow() should already be run.
+///\pre \ref phase2() or run() should already be run.
 template<typename _CutMap>
 void maxMinCut(_CutMap& M) const {
 for(NodeIt v(*g) ; v!=INVALID; ++v) M.set(v, true);

changeset 912	88c5d1a02f53
parent 906	17f31d280385
child 920	2d6c8075d9d0