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

equal deleted inserted replaced

-:2d6beee61874
+:d4d2176a576c
 ///graph. The preflow algorithms are the fastest known max flow algorithms
 ///up to now. The \e source node, the \e target node, the \e
 ///capacity of the edges and the \e starting \e flow value of the
 ///edges should be passed to the algorithm through the
 ///constructor. It is possible to change these quantities using the
-///functions \ref source, \ref target, \ref setCap and \ref
+///functions \ref source, \ref target, \ref capacityMap and \ref
-///setFlow.
+///flowMap.
 ///
 ///After running \ref lemon::Preflow::phase1() "phase1()"
 ///or \ref lemon::Preflow::run() "run()", the maximal flow
 ///value can be obtained by calling \ref flowValue(). The minimum
 ///value cut can be written into a <tt>bool</tt> node map by
 public:
 ///The constructor of the class.
 ///The constructor of the class.
-///\param _G The directed graph the algorithm runs on.
+///\param _gr The directed graph the algorithm runs on.
 ///\param _s The source node.
 ///\param _t The target node.
 ///\param _cap The capacity of the edges.
 ///\param _f The flow of the edges.
 ///Except the graph, all of these parameters can be reset by
-///calling \ref source, \ref target, \ref setCap and \ref
+///calling \ref source, \ref target, \ref capacityMap and \ref
-///setFlow, resp.
+///flowMap, resp.
 Preflow(const Graph& _gr, Node _s, Node _t,
 	      const CapacityMap& _cap, FlowMap& _f) :
 	_g(&_gr), _source(_s), _target(_t), _capacity(&_cap),
 	_flow(&_f), _node_num(countNodes(_gr)), level(_gr), excess(_gr,0),
 	flow_prop(NO_FLOW), status(AFTER_NOTHING) { }
 ///Runs the first phase of the preflow algorithm.
 ///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
+///and a minimum value cut can already be computed, although a
 ///maximum flow is not yet obtained. So after calling this method
 ///\ref flowValue returns the value of a maximum flow and \ref
 ///minCut returns a minimum cut.
 ///\warning \ref minMinCut and \ref maxMinCut do not give minimum
 ///value cuts unless calling \ref phase2.
 ///Runs the first phase of the preflow algorithm.
 ///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
+///and a minimum value cut can already be computed, although a
 ///maximum flow is not yet obtained. So after calling this method
 ///\ref flowValue returns the value of a maximum flow and \ref
 ///minCut returns a minimum cut.
 ///\warning \ref minCut(), \ref minMinCut() and \ref maxMinCut() do not
 ///give minimum value cuts unless calling \ref phase2().
 ///
 void capacityMap(const CapacityMap& _cap) {
 _capacity=&_cap;
 status=AFTER_NOTHING;
 }
-/// Returns a reference to to capacity map.
+/// Returns a reference to capacity map.
-/// Returns a reference to to capacity map.
+/// Returns a reference to capacity map.
 ///
 const CapacityMap &capacityMap() const {
 return *_capacity;
 }
 _flow=&_f;
 flow_prop=NO_FLOW;
 status=AFTER_NOTHING;
 }
-/// Returns a reference to to flow map.
+/// Returns a reference to flow map.
-/// Returns a reference to to flow map.
+/// Returns a reference to flow map.
 ///
 const FlowMap &flowMap() const {
 return *_flow;
 }

changeset 1299	e2545ef5d7d8
parent 1227	01f668e3e168
child 1359	1581f961cfaa