lemon-1.3: comparison lemon/preflow.h

equal deleted inserted replaced

-:38b67a5a07d4
+:1d77739dc169
 /// The type of the map that stores the arc capacities.
 /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
 typedef CAP CapacityMap;
 /// \brief The type of the flow values.
-typedef typename CapacityMap::Value Flow;
+typedef typename CapacityMap::Value Value;
 /// \brief The type of the map that stores the flow values.
 ///
 /// The type of the map that stores the flow values.
 /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-typedef typename Digraph::template ArcMap<Flow> FlowMap;
+typedef typename Digraph::template ArcMap<Value> FlowMap;
 /// \brief Instantiates a FlowMap.
 ///
 /// This function instantiates a \ref FlowMap.
 /// \param digraph The digraph for which we would like to define
 }
 /// \brief The tolerance used by the algorithm
 ///
 /// The tolerance used by the algorithm to handle inexact computation.
-typedef lemon::Tolerance<Flow> Tolerance;
+typedef lemon::Tolerance<Value> Tolerance;
 };
 /// \ingroup max_flow
 ///The type of the digraph the algorithm runs on.
 typedef typename Traits::Digraph Digraph;
 ///The type of the capacity map.
 typedef typename Traits::CapacityMap CapacityMap;
 ///The type of the flow values.
-typedef typename Traits::Flow Flow;
+typedef typename Traits::Value Value;
 ///The type of the flow map.
 typedef typename Traits::FlowMap FlowMap;
 ///The type of the elevator.
 typedef typename Traits::Elevator Elevator;
 bool _local_flow;
 Elevator* _level;
 bool _local_level;
-typedef typename Digraph::template NodeMap<Flow> ExcessMap;
+typedef typename Digraph::template NodeMap<Value> ExcessMap;
 ExcessMap* _excess;
 Tolerance _tolerance;
 bool _phase;
 for (ArcIt e(_graph); e != INVALID; ++e) {
 _flow->set(e, flowMap[e]);
 }
 for (NodeIt n(_graph); n != INVALID; ++n) {
-Flow excess = 0;
+Value excess = 0;
 for (InArcIt e(_graph, n); e != INVALID; ++e) {
 excess += (*_flow)[e];
 }
 for (OutArcIt e(_graph, n); e != INVALID; ++e) {
 excess -= (*_flow)[e];
 queue.swap(nqueue);
 }
 _level->initFinish();
 for (OutArcIt e(_graph, _source); e != INVALID; ++e) {
-Flow rem = (*_capacity)[e] - (*_flow)[e];
+Value rem = (*_capacity)[e] - (*_flow)[e];
 if (_tolerance.positive(rem)) {
 Node u = _graph.target(e);
 if ((*_level)[u] == _level->maxLevel()) continue;
 _flow->set(e, (*_capacity)[e]);
 (*_excess)[u] += rem;
 _level->activate(u);
 }
 }
 }
 for (InArcIt e(_graph, _source); e != INVALID; ++e) {
-Flow rem = (*_flow)[e];
+Value rem = (*_flow)[e];
 if (_tolerance.positive(rem)) {
 Node v = _graph.source(e);
 if ((*_level)[v] == _level->maxLevel()) continue;
 _flow->set(e, 0);
 (*_excess)[v] += rem;
 int level = _level->highestActiveLevel();
 while (n != INVALID) {
 int num = _node_num;
 while (num > 0 && n != INVALID) {
-Flow excess = (*_excess)[n];
+Value excess = (*_excess)[n];
 int new_level = _level->maxLevel();
 for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-Flow rem = (*_capacity)[e] - (*_flow)[e];
+Value rem = (*_capacity)[e] - (*_flow)[e];
 if (!_tolerance.positive(rem)) continue;
 Node v = _graph.target(e);
 if ((*_level)[v] < level) {
 if (!_level->active(v) && v != _target) {
 _level->activate(v);
 new_level = (*_level)[v];
 }
 }
 for (InArcIt e(_graph, n); e != INVALID; ++e) {
-Flow rem = (*_flow)[e];
+Value rem = (*_flow)[e];
 if (!_tolerance.positive(rem)) continue;
 Node v = _graph.source(e);
 if ((*_level)[v] < level) {
 if (!_level->active(v) && v != _target) {
 _level->activate(v);
 --num;
 }
 num = _node_num * 20;
 while (num > 0 && n != INVALID) {
-Flow excess = (*_excess)[n];
+Value excess = (*_excess)[n];
 int new_level = _level->maxLevel();
 for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-Flow rem = (*_capacity)[e] - (*_flow)[e];
+Value rem = (*_capacity)[e] - (*_flow)[e];
 if (!_tolerance.positive(rem)) continue;
 Node v = _graph.target(e);
 if ((*_level)[v] < level) {
 if (!_level->active(v) && v != _target) {
 _level->activate(v);
 new_level = (*_level)[v];
 }
 }
 for (InArcIt e(_graph, n); e != INVALID; ++e) {
-Flow rem = (*_flow)[e];
+Value rem = (*_flow)[e];
 if (!_tolerance.positive(rem)) continue;
 Node v = _graph.source(e);
 if ((*_level)[v] < level) {
 if (!_level->active(v) && v != _target) {
 _level->activate(v);
 }
 }
 Node n;
 while ((n = _level->highestActive()) != INVALID) {
-Flow excess = (*_excess)[n];
+Value excess = (*_excess)[n];
 int level = _level->highestActiveLevel();
 int new_level = _level->maxLevel();
 for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-Flow rem = (*_capacity)[e] - (*_flow)[e];
+Value rem = (*_capacity)[e] - (*_flow)[e];
 if (!_tolerance.positive(rem)) continue;
 Node v = _graph.target(e);
 if ((*_level)[v] < level) {
 if (!_level->active(v) && v != _source) {
 _level->activate(v);
 new_level = (*_level)[v];
 }
 }
 for (InArcIt e(_graph, n); e != INVALID; ++e) {
-Flow rem = (*_flow)[e];
+Value rem = (*_flow)[e];
 if (!_tolerance.positive(rem)) continue;
 Node v = _graph.source(e);
 if ((*_level)[v] < level) {
 if (!_level->active(v) && v != _source) {
 _level->activate(v);
 /// of the target node. This value equals to the value of
 /// the maximum flow already after the first phase of the algorithm.
 ///
 /// \pre Either \ref run() or \ref init() must be called before
 /// using this function.
-Flow flowValue() const {
+Value flowValue() const {
 return (*_excess)[_target];
 }
-/// \brief Returns the flow on the given arc.
+/// \brief Returns the flow value on the given arc.
 ///
-/// Returns the flow on the given arc. This method can
+/// Returns the flow value on the given arc. This method can
 /// be called after the second phase of the algorithm.
 ///
 /// \pre Either \ref run() or \ref init() must be called before
 /// using this function.
-Flow flow(const Arc& arc) const {
+Value flow(const Arc& arc) const {
 return (*_flow)[arc];
 }
 /// \brief Returns a const reference to the flow map.
 ///

changeset 668	7e13120d90a2
parent 611	85cb3aa71cce
child 688	1f08e846df29
child 713	4ac30454f1c1