LEMON/LEMON-official Changeset - r628:aa1804409f29

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r628:aa1804409f29

« 627:2313ed

629:7a28e2 »

r628:aa1804409f29

Tue, 14 Apr 2009 10:35:38

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Exploit that the standard maps are reference maps (#190)

0 9 0

default

9 files changed with 345 insertions and 345 deletions:

lemon/circulation.h

lemon/core.h

lemon/elevator.h

lemon/gomory_hu.h

lemon/hao_orlin.h

lemon/max_matching.h

lemon/min_cost_arborescence.h

lemon/preflow.h

test/kruskal_test.cc

↑ Collapse diff ↑

lemon/circulation.h

Show inline comments

@@ -455,3 +455,3 @@
 		      for(NodeIt n(_g);n!=INVALID;++n) {
-		        _excess->set(n, (*_delta)[n]);
+		        (*_excess)[n] = (*_delta)[n];
+		      }
@@ -460,4 +460,4 @@
 		        _flow->set(e, (*_lo)[e]);
 		        _excess->set(_g.target(e), (*_excess)[_g.target(e)] + (*_flow)[e]);
 		        _excess->set(_g.source(e), (*_excess)[_g.source(e)] - (*_flow)[e]);
 		        (*_excess)[_g.target(e)] += (*_flow)[e];
 		        (*_excess)[_g.source(e)] -= (*_flow)[e];
+		      }
@@ -484,3 +484,3 @@
 		      for(NodeIt n(_g);n!=INVALID;++n) {
-		        _excess->set(n, (*_delta)[n]);
+		        (*_excess)[n] = (*_delta)[n];
+		      }
@@ -490,8 +490,8 @@
 		          _flow->set(e, (*_up)[e]);
 		          _excess->set(_g.target(e), (*_excess)[_g.target(e)] + (*_up)[e]);
 		          _excess->set(_g.source(e), (*_excess)[_g.source(e)] - (*_up)[e]);
 		          (*_excess)[_g.target(e)] += (*_up)[e];
 		          (*_excess)[_g.source(e)] -= (*_up)[e];
 		        } else if (_tol.positive((*_excess)[_g.target(e)] + (*_lo)[e])) {
 		          _flow->set(e, (*_lo)[e]);
 		          _excess->set(_g.target(e), (*_excess)[_g.target(e)] + (*_lo)[e]);
 		          _excess->set(_g.source(e), (*_excess)[_g.source(e)] - (*_lo)[e]);
 		          (*_excess)[_g.target(e)] += (*_lo)[e];
 		          (*_excess)[_g.source(e)] -= (*_lo)[e];
 		        } else {
@@ -499,4 +499,4 @@
 		          _flow->set(e, fc);
 		          _excess->set(_g.target(e), 0);
 		          _excess->set(_g.source(e), (*_excess)[_g.source(e)] - fc);
 		          (*_excess)[_g.target(e)] = 0;
 		          (*_excess)[_g.source(e)] -= fc;
+		        }
@@ -539,6 +539,6 @@
 		              _flow->set(e, (*_flow)[e] + exc);
-		              _excess->set(v, (*_excess)[v] + exc);
+		              (*_excess)[v] += exc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
 		                _level->activate(v);
-		              _excess->set(act,0);
+		              (*_excess)[act] = 0;
 		              _level->deactivate(act);
@@ -548,3 +548,3 @@
 		              _flow->set(e, (*_up)[e]);
-		              _excess->set(v, (*_excess)[v] + fc);
+		              (*_excess)[v] += fc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
@@ -563,6 +563,6 @@
 		              _flow->set(e, (*_flow)[e] - exc);
-		              _excess->set(v, (*_excess)[v] + exc);
+		              (*_excess)[v] += exc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
 		                _level->activate(v);
-		              _excess->set(act,0);
+		              (*_excess)[act] = 0;
 		              _level->deactivate(act);
@@ -572,3 +572,3 @@
 		              _flow->set(e, (*_lo)[e]);
-		              _excess->set(v, (*_excess)[v] + fc);
+		              (*_excess)[v] += fc;
 		              if(!_level->active(v) && _tol.positive((*_excess)[v]))
@@ -581,3 +581,3 @@
-		        _excess->set(act, exc);
+		        (*_excess)[act] = exc;
 		        if(!_tol.positive(exc)) _level->deactivate(act);

lemon/core.h

Show inline comments

@@ -1317,3 +1317,3 @@
 		      for(NodeIt n(_g);n!=INVALID;++n) {
-		        _head.set(n, INVALID);
+		        _head[n] = INVALID;
+		      }
@@ -1324,4 +1324,4 @@
 		      Node t = _g.target(arc);
 		      _left.set(arc, INVALID);
 		      _right.set(arc, INVALID);
 		      _left[arc] = INVALID;
 		      _right[arc] = INVALID;
@@ -1329,4 +1329,4 @@
 		      if (e == INVALID) {
 		        _head.set(s, arc);
 		        _parent.set(arc, INVALID);
 		        _head[s] = arc;
 		        _parent[arc] = INVALID;
 		        return;
@@ -1336,4 +1336,4 @@
 		          if (_left[e] == INVALID) {
 		            _left.set(e, arc);
 		            _parent.set(arc, e);
 		            _left[e] = arc;
 		            _parent[arc] = e;
 		            splay(arc);
@@ -1345,4 +1345,4 @@
 		          if (_right[e] == INVALID) {
 		            _right.set(e, arc);
 		            _parent.set(arc, e);
 		            _right[e] = arc;
 		            _parent[arc] = e;
 		            splay(arc);
@@ -1359,3 +1359,3 @@
 		        if (_right[arc] != INVALID) {
-		          _parent.set(_right[arc], _parent[arc]);
+		          _parent[_right[arc]] = _parent[arc];
+		        }
@@ -1363,19 +1363,19 @@
 		          if (_left[_parent[arc]] == arc) {
-		            _left.set(_parent[arc], _right[arc]);
+		            _left[_parent[arc]] = _right[arc];
 		          } else {
-		            _right.set(_parent[arc], _right[arc]);
+		            _right[_parent[arc]] = _right[arc];
+		          }
 		        } else {
-		          _head.set(_g.source(arc), _right[arc]);
+		          _head[_g.source(arc)] = _right[arc];
+		        }
 		      } else if (_right[arc] == INVALID) {
-		        _parent.set(_left[arc], _parent[arc]);
+		        _parent[_left[arc]] = _parent[arc];
 		        if (_parent[arc] != INVALID) {
 		          if (_left[_parent[arc]] == arc) {
-		            _left.set(_parent[arc], _left[arc]);
+		            _left[_parent[arc]] = _left[arc];
 		          } else {
-		            _right.set(_parent[arc], _left[arc]);
+		            _right[_parent[arc]] = _left[arc];
+		          }
 		        } else {
-		          _head.set(_g.source(arc), _left[arc]);
+		          _head[_g.source(arc)] = _left[arc];
+		        }
@@ -1389,18 +1389,18 @@
 		          Arc s = _parent[e];
-		          _right.set(_parent[e], _left[e]);
+		          _right[_parent[e]] = _left[e];
 		          if (_left[e] != INVALID) {
-		            _parent.set(_left[e], _parent[e]);
+		            _parent[_left[e]] = _parent[e];
+		          }
 		          _left.set(e, _left[arc]);
 		          _parent.set(_left[arc], e);
 		          _right.set(e, _right[arc]);
 		          _parent.set(_right[arc], e);
 		          _left[e] = _left[arc];
 		          _parent[_left[arc]] = e;
 		          _right[e] = _right[arc];
 		          _parent[_right[arc]] = e;
-		          _parent.set(e, _parent[arc]);
+		          _parent[e] = _parent[arc];
 		          if (_parent[arc] != INVALID) {
 		            if (_left[_parent[arc]] == arc) {
-		              _left.set(_parent[arc], e);
+		              _left[_parent[arc]] = e;
 		            } else {
-		              _right.set(_parent[arc], e);
+		              _right[_parent[arc]] = e;
+		            }
@@ -1409,5 +1409,5 @@
 		        } else {
 		          _right.set(e, _right[arc]);
 		          _parent.set(_right[arc], e);
-		          _parent.set(e, _parent[arc]);
+		          _right[e] = _right[arc];
 		          _parent[_right[arc]] = e;
 		          _parent[e] = _parent[arc];
@@ -1415,8 +1415,8 @@
 		            if (_left[_parent[arc]] == arc) {
-		              _left.set(_parent[arc], e);
+		              _left[_parent[arc]] = e;
 		            } else {
-		              _right.set(_parent[arc], e);
+		              _right[_parent[arc]] = e;
+		            }
 		          } else {
-		            _head.set(_g.source(arc), e);
+		            _head[_g.source(arc)] = e;
+		          }
@@ -1432,6 +1432,6 @@
 		        Arc left = refreshRec(v,a,m-1);
 		        _left.set(me, left);
 		        _parent.set(left, me);
 		        _left[me] = left;
 		        _parent[left] = me;
 		      } else {
-		        _left.set(me, INVALID);
+		        _left[me] = INVALID;
+		      }
@@ -1439,6 +1439,6 @@
 		        Arc right = refreshRec(v,m+1,b);
 		        _right.set(me, right);
 		        _parent.set(right, me);
 		        _right[me] = right;
 		        _parent[right] = me;
 		      } else {
-		        _right.set(me, INVALID);
+		        _right[me] = INVALID;
+		      }
@@ -1454,6 +1454,6 @@
 		          Arc head = refreshRec(v,0,v.size()-1);
 		          _head.set(n, head);
 		          _parent.set(head, INVALID);
 		          _head[n] = head;
 		          _parent[head] = INVALID;
+		        }
-		        else _head.set(n, INVALID);
+		        else _head[n] = INVALID;
+		      }
@@ -1463,11 +1463,11 @@
 		      Arc w = _parent[v];
 		      _parent.set(v, _parent[w]);
 		      _parent.set(w, v);
 		      _left.set(w, _right[v]);
 		      _right.set(v, w);
 		      _parent[v] = _parent[w];
 		      _parent[w] = v;
 		      _left[w] = _right[v];
 		      _right[v] = w;
 		      if (_parent[v] != INVALID) {
 		        if (_right[_parent[v]] == w) {
-		          _right.set(_parent[v], v);
+		          _right[_parent[v]] = v;
 		        } else {
-		          _left.set(_parent[v], v);
+		          _left[_parent[v]] = v;
+		        }
@@ -1475,3 +1475,3 @@
 		      if (_left[w] != INVALID){
-		        _parent.set(_left[w], w);
+		        _parent[_left[w]] = w;
+		      }
@@ -1481,11 +1481,11 @@
 		      Arc w = _parent[v];
 		      _parent.set(v, _parent[w]);
 		      _parent.set(w, v);
 		      _right.set(w, _left[v]);
 		      _left.set(v, w);
 		      _parent[v] = _parent[w];
 		      _parent[w] = v;
 		      _right[w] = _left[v];
 		      _left[v] = w;
 		      if (_parent[v] != INVALID){
 		        if (_left[_parent[v]] == w) {
-		          _left.set(_parent[v], v);
+		          _left[_parent[v]] = v;
 		        } else {
-		          _right.set(_parent[v], v);
+		          _right[_parent[v]] = v;
+		        }
@@ -1493,3 +1493,3 @@
 		      if (_right[w] != INVALID){
-		        _parent.set(_right[w], w);
+		        _parent[_right[w]] = w;
+		      }

lemon/elevator.h

Show inline comments

@@ -78,3 +78,3 @@
+		    {
-		      _where.set(*p=i,p);
+		      _where[*p=i] = p;
+		    }
@@ -86,3 +86,3 @@
 		          *p=i;
-		          _where.set(i,p);
+		          _where[i] = p;
+		        }
@@ -93,4 +93,4 @@
 		      Vit ct = _where[ti];
 		      _where.set(ti,_where[*i=*j]);
 		      _where.set(*j,ct);
 		      _where[ti] = _where[*i=*j];
 		      _where[*j] = ct;
 		      *j=ti;
@@ -228,3 +228,3 @@
 		      Item it = *_last_active[_highest_active];
-		      _level.set(it,_level[it]+1);
+		      ++_level[it];
 		      swap(_last_active[_highest_active]--,_last_active[_highest_active+1]);
@@ -251,3 +251,3 @@
 		      copy(li,_first[new_level]);
-		      _level.set(li,new_level);
+		      _level[li] = new_level;
 		      _highest_active=new_level;
@@ -271,3 +271,3 @@
 		      --_last_active[_max_level];
-		      _level.set(li,_max_level);
+		      _level[li] = _max_level;
@@ -301,3 +301,3 @@
 		      Item it =*_last_active[level];
-		      _level.set(it,_level[it]+1);
+		      ++_level[it];
 		      swap(_last_active[level]--, --_first[level+1]);
@@ -321,3 +321,3 @@
 		      copy(ai,_first[new_level]);
-		      _level.set(ai,new_level);
+		      _level[ai] = new_level;
 		      if (new_level>_highest_active) _highest_active=new_level;
@@ -341,3 +341,3 @@
 		      --_last_active[_max_level];
-		      _level.set(ai,_max_level);
+		      _level[ai] = _max_level;
@@ -372,3 +372,3 @@
 		      copy(i,_first[new_level]);
-		      _level.set(i,new_level);
+		      _level[i] = new_level;
 		      if(new_level>_highest_active) _highest_active=new_level;
@@ -384,3 +384,3 @@
 		    void dirtyTopButOne(Item i) {
-		      _level.set(i,_max_level - 1);
+		      _level[i] = _max_level - 1;
+		    }
@@ -396,3 +396,3 @@
 		      for(Vit i=f;i!=tl;++i)
-		        _level.set(*i,_max_level);
+		        _level[*i] = _max_level;
 		      for(int i=l;i<=_max_level;i++)
@@ -435,4 +435,4 @@
 		          *n=i;
 		          _where.set(i,n);
 		          _level.set(i,_max_level);
 		          _where[i] = n;
 		          _level[i] = _max_level;
 		          ++n;
@@ -445,3 +445,3 @@
 		      swap(_where[i],_init_num);
-		      _level.set(i,_init_lev);
+		      _level[i] = _init_lev;
 		      ++_init_num;
@@ -553,3 +553,3 @@
 		    void activate(Item i) {
-		      _active.set(i, true);
+		      _active[i] = true;
@@ -562,5 +562,5 @@
 		      //unlace
-		      _next.set(_prev[i], _next[i]);
+		      _next[_prev[i]] = _next[i];
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], _prev[i]);
+		        _prev[_next[i]] = _prev[i];
 		      } else {
@@ -569,5 +569,5 @@
 		      //lace
 		      _next.set(i, _first[level]);
 		      _prev.set(_first[level], i);
-		      _prev.set(i, INVALID);
+		      _next[i] = _first[level];
 		      _prev[_first[level]] = i;
 		      _prev[i] = INVALID;
 		      _first[level] = i;
@@ -581,3 +581,3 @@
 		    void deactivate(Item i) {
-		      _active.set(i, false);
+		      _active[i] = false;
 		      int level = _level[i];
@@ -588,5 +588,5 @@
 		      //unlace
-		      _prev.set(_next[i], _prev[i]);
+		      _prev[_next[i]] = _prev[i];
 		      if (_prev[i] != INVALID) {
-		        _next.set(_prev[i], _next[i]);
+		        _next[_prev[i]] = _next[i];
 		      } else {
@@ -595,5 +595,5 @@
 		      //lace
 		      _prev.set(i, _last[level]);
 		      _next.set(_last[level], i);
-		      _next.set(i, INVALID);
+		      _prev[i] = _last[level];
 		      _next[_last[level]] = i;
 		      _next[i] = INVALID;
 		      _last[level] = i;
@@ -687,3 +687,3 @@
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], INVALID);
+		        _prev[_next[i]] = INVALID;
 		        _first[_highest_active] = _next[i];
@@ -693,3 +693,3 @@
+		      }
-		      _level.set(i, ++_highest_active);
+		      _level[i] = ++_highest_active;
 		      if (_first[_highest_active] == INVALID) {
@@ -697,7 +697,7 @@
 		        _last[_highest_active] = i;
 		        _prev.set(i, INVALID);
 		        _next.set(i, INVALID);
 		        _prev[i] = INVALID;
 		        _next[i] = INVALID;
 		      } else {
 		        _prev.set(_first[_highest_active], i);
 		        _next.set(i, _first[_highest_active]);
 		        _prev[_first[_highest_active]] = i;
 		        _next[i] = _first[_highest_active];
 		        _first[_highest_active] = i;
@@ -716,3 +716,3 @@
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], INVALID);
+		        _prev[_next[i]] = INVALID;
 		        _first[_highest_active] = _next[i];
@@ -722,10 +722,10 @@
+		      }
-		      _level.set(i, _highest_active = new_level);
+		      _level[i] = _highest_active = new_level;
 		      if (_first[_highest_active] == INVALID) {
 		        _first[_highest_active] = _last[_highest_active] = i;
 		        _prev.set(i, INVALID);
 		        _next.set(i, INVALID);
 		        _prev[i] = INVALID;
 		        _next[i] = INVALID;
 		      } else {
 		        _prev.set(_first[_highest_active], i);
 		        _next.set(i, _first[_highest_active]);
 		        _prev[_first[_highest_active]] = i;
 		        _next[i] = _first[_highest_active];
 		        _first[_highest_active] = i;
@@ -740,5 +740,5 @@
 		      Item i = _first[_highest_active];
-		      _level.set(i, _max_level);
+		      _level[i] = _max_level;
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], INVALID);
+		        _prev[_next[i]] = INVALID;
 		        _first[_highest_active] = _next[i];
@@ -776,3 +776,3 @@
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], INVALID);
+		        _prev[_next[i]] = INVALID;
 		        _first[l] = _next[i];
@@ -782,10 +782,10 @@
+		      }
-		      _level.set(i, ++l);
+		      _level[i] = ++l;
 		      if (_first[l] == INVALID) {
 		        _first[l] = _last[l] = i;
 		        _prev.set(i, INVALID);
 		        _next.set(i, INVALID);
 		        _prev[i] = INVALID;
 		        _next[i] = INVALID;
 		      } else {
 		        _prev.set(_first[l], i);
 		        _next.set(i, _first[l]);
 		        _prev[_first[l]] = i;
 		        _next[i] = _first[l];
 		        _first[l] = i;
@@ -805,3 +805,3 @@
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], INVALID);
+		        _prev[_next[i]] = INVALID;
 		        _first[l] = _next[i];
@@ -811,10 +811,10 @@
+		      }
-		      _level.set(i, l = new_level);
+		      _level[i] = l = new_level;
 		      if (_first[l] == INVALID) {
 		        _first[l] = _last[l] = i;
 		        _prev.set(i, INVALID);
 		        _next.set(i, INVALID);
 		        _prev[i] = INVALID;
 		        _next[i] = INVALID;
 		      } else {
 		        _prev.set(_first[l], i);
 		        _next.set(i, _first[l]);
 		        _prev[_first[l]] = i;
 		        _next[i] = _first[l];
 		        _first[l] = i;
@@ -834,3 +834,3 @@
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], INVALID);
+		        _prev[_next[i]] = INVALID;
 		        _first[l] = _next[i];
@@ -840,3 +840,3 @@
+		      }
-		      _level.set(i, _max_level);
+		      _level[i] = _max_level;
 		      if (l == _highest_active) {
@@ -858,3 +858,3 @@
 		      if (_next[i] != INVALID) {
-		        _prev.set(_next[i], _prev[i]);
+		        _prev[_next[i]] = _prev[i];
 		      } else {
@@ -863,3 +863,3 @@
 		      if (_prev[i] != INVALID) {
-		        _next.set(_prev[i], _next[i]);
+		        _next[_prev[i]] = _next[i];
 		      } else {
@@ -867,10 +867,10 @@
+		      }
-		      _level.set(i, new_level);
+		      _level[i] = new_level;
 		      if (_first[new_level] == INVALID) {
 		        _first[new_level] = _last[new_level] = i;
 		        _prev.set(i, INVALID);
 		        _next.set(i, INVALID);
 		        _prev[i] = INVALID;
 		        _next[i] = INVALID;
 		      } else {
 		        _prev.set(_first[new_level], i);
 		        _next.set(i, _first[new_level]);
 		        _prev[_first[new_level]] = i;
 		        _next[i] = _first[new_level];
 		        _first[new_level] = i;
@@ -890,3 +890,3 @@
 		    void dirtyTopButOne(Item i) {
-		      _level.set(i, _max_level - 1);
+		      _level[i] = _max_level - 1;
+		    }
@@ -901,3 +901,3 @@
 		        while (n != INVALID) {
-		          _level.set(n, _max_level);
+		          _level[n] = _max_level;
 		          n = _next[n];
@@ -939,4 +939,4 @@
 		          i != INVALID; ++i) {
 		        _level.set(i, _max_level);
 		        _active.set(i, false);
 		        _level[i] = _max_level;
 		        _active[i] = false;
+		      }
@@ -946,3 +946,3 @@
 		    void initAddItem(Item i) {
-		      _level.set(i, _init_level);
+		      _level[i] = _init_level;
 		      if (_last[_init_level] == INVALID) {
@@ -950,8 +950,8 @@
 		        _last[_init_level] = i;
 		        _prev.set(i, INVALID);
 		        _next.set(i, INVALID);
 		        _prev[i] = INVALID;
 		        _next[i] = INVALID;
 		      } else {
 		        _prev.set(i, _last[_init_level]);
 		        _next.set(i, INVALID);
-		        _next.set(_last[_init_level], i);
+		        _prev[i] = _last[_init_level];
 		        _next[i] = INVALID;
 		        _next[_last[_init_level]] = i;
 		        _last[_init_level] = i;

lemon/gomory_hu.h

Show inline comments

@@ -145,7 +145,7 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 			_pred->set(n, _root);
 			_order->set(n, -1);
 		        (*_pred)[n] = _root;
 		        (*_order)[n] = -1;
+		      }
 		      _pred->set(_root, INVALID);
 		      _weight->set(_root, std::numeric_limits<Value>::max());
 		      (*_pred)[_root] = INVALID;
 		      (*_weight)[_root] = std::numeric_limits<Value>::max();
+		    }
@@ -166,3 +166,3 @@
-			_weight->set(n, fa.flowValue());
+			(*_weight)[n] = fa.flowValue();
@@ -170,3 +170,3 @@
 			  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
-			    _pred->set(nn, n);
+			    (*_pred)[nn] = n;
+			  }
@@ -174,6 +174,6 @@
 			if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
 			  _pred->set(n, (*_pred)[pn]);
 			  _pred->set(pn, n);
 			  _weight->set(n, (*_weight)[pn]);
 			  _weight->set(pn, fa.flowValue());
 			  (*_pred)[n] = (*_pred)[pn];
 			  (*_pred)[pn] = n;
 			  (*_weight)[n] = (*_weight)[pn];
 			  (*_weight)[pn] = fa.flowValue();
+			}
@@ -181,3 +181,3 @@
-		      _order->set(_root, 0);
+		      (*_order)[_root] = 0;
 		      int index = 1;
@@ -192,3 +192,3 @@
 			while (!st.empty()) {
-			  _order->set(st.back(), index++);
+			  (*_order)[st.back()] = index++;
 			  st.pop_back();
@@ -311,5 +311,5 @@
 		      typename Graph::template NodeMap<bool> reached(_graph, false);
-		      reached.set(_root, true);
+		      reached[_root] = true;
 		      cutMap.set(_root, !s_root);
-		      reached.set(rn, true);
+		      reached[rn] = true;
 		      cutMap.set(rn, s_root);

lemon/hao_orlin.h

Show inline comments

@@ -163,3 +163,3 @@
 		    void activate(const Node& i) {
-		      _active->set(i, true);
+		      (*_active)[i] = true;
@@ -169,5 +169,5 @@
 		      //unlace
-		      _next->set((*_prev)[i], (*_next)[i]);
+		      (*_next)[(*_prev)[i]] = (*_next)[i];
 		      if ((*_next)[i] != INVALID) {
-		        _prev->set((*_next)[i], (*_prev)[i]);
+		        (*_prev)[(*_next)[i]] = (*_prev)[i];
 		      } else {
@@ -176,5 +176,5 @@
 		      //lace
 		      _next->set(i, _first[bucket]);
 		      _prev->set(_first[bucket], i);
-		      _prev->set(i, INVALID);
+		      (*_next)[i] = _first[bucket];
 		      (*_prev)[_first[bucket]] = i;
 		      (*_prev)[i] = INVALID;
 		      _first[bucket] = i;
@@ -183,3 +183,3 @@
 		    void deactivate(const Node& i) {
-		      _active->set(i, false);
+		      (*_active)[i] = false;
 		      int bucket = (*_bucket)[i];
@@ -189,5 +189,5 @@
 		      //unlace
-		      _prev->set((*_next)[i], (*_prev)[i]);
+		      (*_prev)[(*_next)[i]] = (*_prev)[i];
 		      if ((*_prev)[i] != INVALID) {
-		        _next->set((*_prev)[i], (*_next)[i]);
+		        (*_next)[(*_prev)[i]] = (*_next)[i];
 		      } else {
@@ -196,5 +196,5 @@
 		      //lace
 		      _prev->set(i, _last[bucket]);
 		      _next->set(_last[bucket], i);
-		      _next->set(i, INVALID);
+		      (*_prev)[i] = _last[bucket];
 		      (*_next)[_last[bucket]] = i;
 		      (*_next)[i] = INVALID;
 		      _last[bucket] = i;
@@ -205,10 +205,10 @@
 		      if (_last[bucket] != INVALID) {
 		        _prev->set(i, _last[bucket]);
 		        _next->set(_last[bucket], i);
-		        _next->set(i, INVALID);
+		        (*_prev)[i] = _last[bucket];
 		        (*_next)[_last[bucket]] = i;
 		        (*_next)[i] = INVALID;
 		        _last[bucket] = i;
 		      } else {
-		        _prev->set(i, INVALID);
+		        (*_prev)[i] = INVALID;
 		        _first[bucket] = i;
-		        _next->set(i, INVALID);
+		        (*_next)[i] = INVALID;
 		        _last[bucket] = i;
@@ -220,3 +220,3 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
-		        _excess->set(n, 0);
+		        (*_excess)[n] = 0;
+		      }
@@ -224,3 +224,3 @@
 		      for (ArcIt a(_graph); a != INVALID; ++a) {
-		        _flow->set(a, 0);
+		        (*_flow)[a] = 0;
+		      }
@@ -234,3 +234,3 @@
-		        reached.set(_source, true);
+		        reached[_source] = true;
 		        bool first_set = true;
@@ -242,3 +242,3 @@
 		          queue[qlast++] = t;
-		          reached.set(t, true);
+		          reached[t] = true;
@@ -259,3 +259,3 @@
 		              if (!reached[u] && _tolerance.positive((*_capacity)[a])) {
-		                reached.set(u, true);
+		                reached[u] = true;
 		                queue[qlast++] = u;
@@ -268,6 +268,6 @@
 		        ++bucket_num;
-		        _bucket->set(_source, 0);
+		        (*_bucket)[_source] = 0;
 		        _dormant[0] = true;
+		      }
-		      _source_set->set(_source, true);
+		      (*_source_set)[_source] = true;
@@ -278,4 +278,4 @@
 		            Node u = _graph.target(a);
 		            _flow->set(a, (*_capacity)[a]);
 		            _excess->set(u, (*_excess)[u] + (*_capacity)[a]);
 		            (*_flow)[a] = (*_capacity)[a];
 		            (*_excess)[u] += (*_capacity)[a];
 		            if (!(*_active)[u] && u != _source) {
@@ -320,4 +320,4 @@
 		              if (!_tolerance.less(rem, excess)) {
 		                _flow->set(a, (*_flow)[a] + excess);
 		                _excess->set(v, (*_excess)[v] + excess);
 		                (*_flow)[a] += excess;
 		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -326,4 +326,4 @@
 		                excess -= rem;
 		                _excess->set(v, (*_excess)[v] + rem);
 		                _flow->set(a, (*_capacity)[a]);
 		                (*_excess)[v] += rem;
 		                (*_flow)[a] = (*_capacity)[a];
+		              }
@@ -344,4 +344,4 @@
 		              if (!_tolerance.less(rem, excess)) {
 		                _flow->set(a, (*_flow)[a] - excess);
 		                _excess->set(v, (*_excess)[v] + excess);
 		                (*_flow)[a] -= excess;
 		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -350,4 +350,4 @@
 		                excess -= rem;
 		                _excess->set(v, (*_excess)[v] + rem);
 		                _flow->set(a, 0);
 		                (*_excess)[v] += rem;
 		                (*_flow)[a] = 0;
+		              }
@@ -360,3 +360,3 @@
-		          _excess->set(n, excess);
+		          (*_excess)[n] = excess;
@@ -378,3 +378,3 @@
 		              _first[(*_bucket)[n]] = (*_next)[n];
-		              _prev->set((*_next)[n], INVALID);
+		              (*_prev)[(*_next)[n]] = INVALID;
@@ -384,6 +384,6 @@
 		              new_set->push_front(bucket_num);
-		              _bucket->set(n, bucket_num);
+		              (*_bucket)[n] = bucket_num;
 		              _first[bucket_num] = _last[bucket_num] = n;
 		              _next->set(n, INVALID);
 		              _prev->set(n, INVALID);
 		              (*_next)[n] = INVALID;
 		              (*_prev)[n] = INVALID;
 		              _dormant[bucket_num] = true;
@@ -397,3 +397,3 @@
 		              _first[*_highest] = (*_next)[n];
-		              _prev->set((*_next)[n], INVALID);
+		              (*_prev)[(*_next)[n]] = INVALID;
@@ -411,6 +411,6 @@
 		              _bucket->set(n, *_highest);
 		              _next->set(n, _first[*_highest]);
 		              (*_bucket)[n] = *_highest;
 		              (*_next)[n] = _first[*_highest];
 		              if (_first[*_highest] != INVALID) {
-		                _prev->set(_first[*_highest], n);
+		                (*_prev)[_first[*_highest]] = n;
 		              } else {
@@ -436,3 +436,3 @@
 		          for (NodeIt i(_graph); i != INVALID; ++i) {
-		            _min_cut_map->set(i, true);
+		            (*_min_cut_map)[i] = true;
+		          }
@@ -442,3 +442,3 @@
 		            while (n != INVALID) {
-		              _min_cut_map->set(n, false);
+		              (*_min_cut_map)[n] = false;
 		              n = (*_next)[n];
@@ -455,3 +455,3 @@
 		            } else {
-		              _prev->set((*_next)[target], (*_prev)[target]);
+		              (*_prev)[(*_next)[target]] = (*_prev)[target];
 		              new_target = (*_next)[target];
@@ -461,3 +461,3 @@
 		            } else {
-		              _next->set((*_prev)[target], (*_next)[target]);
+		              (*_next)[(*_prev)[target]] = (*_next)[target];
+		            }
@@ -477,5 +477,5 @@
-		          _bucket->set(target, 0);
+		          (*_bucket)[target] = 0;
-		          _source_set->set(target, true);
+		          (*_source_set)[target] = true;
 		          for (OutArcIt a(_graph, target); a != INVALID; ++a) {
@@ -487,4 +487,4 @@
+		            }
 		            _excess->set(v, (*_excess)[v] + rem);
 		            _flow->set(a, (*_capacity)[a]);
 		            (*_excess)[v] += rem;
 		            (*_flow)[a] = (*_capacity)[a];
+		          }
@@ -498,4 +498,4 @@
+		            }
 		            _excess->set(v, (*_excess)[v] + rem);
 		            _flow->set(a, 0);
 		            (*_excess)[v] += rem;
 		            (*_flow)[a] = 0;
+		          }
@@ -519,3 +519,3 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
-		        _excess->set(n, 0);
+		        (*_excess)[n] = 0;
+		      }
@@ -523,3 +523,3 @@
 		      for (ArcIt a(_graph); a != INVALID; ++a) {
-		        _flow->set(a, 0);
+		        (*_flow)[a] = 0;
+		      }
@@ -533,3 +533,3 @@
-		        reached.set(_source, true);
+		        reached[_source] = true;
@@ -542,3 +542,3 @@
 		          queue[qlast++] = t;
-		          reached.set(t, true);
+		          reached[t] = true;
@@ -559,3 +559,3 @@
 		              if (!reached[u] && _tolerance.positive((*_capacity)[a])) {
-		                reached.set(u, true);
+		                reached[u] = true;
 		                queue[qlast++] = u;
@@ -568,6 +568,6 @@
 		        ++bucket_num;
-		        _bucket->set(_source, 0);
+		        (*_bucket)[_source] = 0;
 		        _dormant[0] = true;
+		      }
-		      _source_set->set(_source, true);
+		      (*_source_set)[_source] = true;
@@ -578,4 +578,4 @@
 		            Node u = _graph.source(a);
 		            _flow->set(a, (*_capacity)[a]);
 		            _excess->set(u, (*_excess)[u] + (*_capacity)[a]);
 		            (*_flow)[a] = (*_capacity)[a];
 		            (*_excess)[u] += (*_capacity)[a];
 		            if (!(*_active)[u] && u != _source) {
@@ -620,4 +620,4 @@
 		              if (!_tolerance.less(rem, excess)) {
 		                _flow->set(a, (*_flow)[a] + excess);
 		                _excess->set(v, (*_excess)[v] + excess);
 		                (*_flow)[a] += excess;
 		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -626,4 +626,4 @@
 		                excess -= rem;
 		                _excess->set(v, (*_excess)[v] + rem);
 		                _flow->set(a, (*_capacity)[a]);
 		                (*_excess)[v] += rem;
 		                (*_flow)[a] = (*_capacity)[a];
+		              }
@@ -644,4 +644,4 @@
 		              if (!_tolerance.less(rem, excess)) {
 		                _flow->set(a, (*_flow)[a] - excess);
 		                _excess->set(v, (*_excess)[v] + excess);
 		                (*_flow)[a] -= excess;
 		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -650,4 +650,4 @@
 		                excess -= rem;
 		                _excess->set(v, (*_excess)[v] + rem);
 		                _flow->set(a, 0);
 		                (*_excess)[v] += rem;
 		                (*_flow)[a] = 0;
+		              }
@@ -660,3 +660,3 @@
-		          _excess->set(n, excess);
+		          (*_excess)[n] = excess;
@@ -678,3 +678,3 @@
 		              _first[(*_bucket)[n]] = (*_next)[n];
-		              _prev->set((*_next)[n], INVALID);
+		              (*_prev)[(*_next)[n]] = INVALID;
@@ -684,6 +684,6 @@
 		              new_set->push_front(bucket_num);
-		              _bucket->set(n, bucket_num);
+		              (*_bucket)[n] = bucket_num;
 		              _first[bucket_num] = _last[bucket_num] = n;
 		              _next->set(n, INVALID);
 		              _prev->set(n, INVALID);
 		              (*_next)[n] = INVALID;
 		              (*_prev)[n] = INVALID;
 		              _dormant[bucket_num] = true;
@@ -697,3 +697,3 @@
 		              _first[*_highest] = (*_next)[n];
-		              _prev->set((*_next)[n], INVALID);
+		              (*_prev)[(*_next)[n]] = INVALID;
@@ -710,6 +710,6 @@
 		              _bucket->set(n, *_highest);
 		              _next->set(n, _first[*_highest]);
 		              (*_bucket)[n] = *_highest;
 		              (*_next)[n] = _first[*_highest];
 		              if (_first[*_highest] != INVALID) {
-		                _prev->set(_first[*_highest], n);
+		                (*_prev)[_first[*_highest]] = n;
 		              } else {
@@ -735,3 +735,3 @@
 		          for (NodeIt i(_graph); i != INVALID; ++i) {
-		            _min_cut_map->set(i, false);
+		            (*_min_cut_map)[i] = false;
+		          }
@@ -741,3 +741,3 @@
 		            while (n != INVALID) {
-		              _min_cut_map->set(n, true);
+		              (*_min_cut_map)[n] = true;
 		              n = (*_next)[n];
@@ -754,3 +754,3 @@
 		            } else {
-		              _prev->set((*_next)[target], (*_prev)[target]);
+		              (*_prev)[(*_next)[target]] = (*_prev)[target];
 		              new_target = (*_next)[target];
@@ -760,3 +760,3 @@
 		            } else {
-		              _next->set((*_prev)[target], (*_next)[target]);
+		              (*_next)[(*_prev)[target]] = (*_next)[target];
+		            }
@@ -776,5 +776,5 @@
-		          _bucket->set(target, 0);
+		          (*_bucket)[target] = 0;
-		          _source_set->set(target, true);
+		          (*_source_set)[target] = true;
 		          for (InArcIt a(_graph, target); a != INVALID; ++a) {
@@ -786,4 +786,4 @@
+		            }
 		            _excess->set(v, (*_excess)[v] + rem);
 		            _flow->set(a, (*_capacity)[a]);
 		            (*_excess)[v] += rem;
 		            (*_flow)[a] = (*_capacity)[a];
+		          }
@@ -797,4 +797,4 @@
+		            }
 		            _excess->set(v, (*_excess)[v] + rem);
 		            _flow->set(a, 0);
 		            (*_excess)[v] += rem;
 		            (*_flow)[a] = 0;
+		          }

lemon/max_matching.h

Show inline comments

@@ -284,3 +284,3 @@
 		        while (base != nca) {
-		          _ear->set(node, arc);
+		          (*_ear)[node] = arc;
@@ -291,3 +291,3 @@
 		            n = _graph.target(a);
-		            _ear->set(n, _graph.oppositeArc(a));
+		            (*_ear)[n] = _graph.oppositeArc(a);
+		          }
@@ -297,3 +297,3 @@
 		          _blossom_set->insert(node, _blossom_set->find(base));
-		          _status->set(node, EVEN);
+		          (*_status)[node] = EVEN;
 		          _node_queue[_last++] = node;
@@ -306,3 +306,3 @@
-		      _blossom_rep->set(_blossom_set->find(nca), nca);
+		      (*_blossom_rep)[_blossom_set->find(nca)] = nca;
@@ -315,3 +315,3 @@
 		        while (base != nca) {
-		          _ear->set(node, arc);
+		          (*_ear)[node] = arc;
@@ -322,3 +322,3 @@
 		            n = _graph.target(a);
-		            _ear->set(n, _graph.oppositeArc(a));
+		            (*_ear)[n] = _graph.oppositeArc(a);
+		          }
@@ -328,3 +328,3 @@
 		          _blossom_set->insert(node, _blossom_set->find(base));
-		          _status->set(node, EVEN);
+		          (*_status)[node] = EVEN;
 		          _node_queue[_last++] = node;
@@ -337,3 +337,3 @@
-		      _blossom_rep->set(_blossom_set->find(nca), nca);
+		      (*_blossom_rep)[_blossom_set->find(nca)] = nca;
+		    }
@@ -346,7 +346,7 @@
-		      _ear->set(odd, _graph.oppositeArc(a));
+		      (*_ear)[odd] = _graph.oppositeArc(a);
 		      Node even = _graph.target((*_matching)[odd]);
 		      _blossom_rep->set(_blossom_set->insert(even), even);
 		      _status->set(odd, ODD);
-		      _status->set(even, EVEN);
+		      (*_blossom_rep)[_blossom_set->insert(even)] = even;
 		      (*_status)[odd] = ODD;
 		      (*_status)[even] = EVEN;
 		      int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(base)]);
@@ -364,7 +364,7 @@
 		      _matching->set(odd, _graph.oppositeArc(a));
 		      _status->set(odd, MATCHED);
 		      (*_matching)[odd] = _graph.oppositeArc(a);
 		      (*_status)[odd] = MATCHED;
 		      Arc arc = (*_matching)[even];
-		      _matching->set(even, a);
+		      (*_matching)[even] = a;
@@ -374,5 +374,5 @@
 		        even = _graph.target(arc);
-		        _matching->set(odd, arc);
+		        (*_matching)[odd] = arc;
 		        arc = (*_matching)[even];
-		        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
+		        (*_matching)[even] = _graph.oppositeArc((*_matching)[odd]);
+		      }
@@ -382,3 +382,3 @@
 		        if ((*_status)[it] == ODD) {
-		          _status->set(it, MATCHED);
+		          (*_status)[it] = MATCHED;
 		        } else {
@@ -387,3 +387,3 @@
 		               jt != INVALID; ++jt) {
-		            _status->set(jt, MATCHED);
+		            (*_status)[jt] = MATCHED;
+		          }
@@ -429,4 +429,4 @@
 		      for(NodeIt n(_graph); n != INVALID; ++n) {
 		        _matching->set(n, INVALID);
 		        _status->set(n, UNMATCHED);
 		        (*_matching)[n] = INVALID;
 		        (*_status)[n] = UNMATCHED;
+		      }
@@ -440,4 +440,4 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        _matching->set(n, INVALID);
 		        _status->set(n, UNMATCHED);
 		        (*_matching)[n] = INVALID;
 		        (*_status)[n] = UNMATCHED;
+		      }
@@ -448,6 +448,6 @@
 		            if ((*_matching)[v] == INVALID && v != n) {
 		              _matching->set(n, a);
 		              _status->set(n, MATCHED);
 		              _matching->set(v, _graph.oppositeArc(a));
 		              _status->set(v, MATCHED);
 		              (*_matching)[n] = a;
 		              (*_status)[n] = MATCHED;
 		              (*_matching)[v] = _graph.oppositeArc(a);
 		              (*_status)[v] = MATCHED;
 		              break;
@@ -471,4 +471,4 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        _matching->set(n, INVALID);
 		        _status->set(n, UNMATCHED);
 		        (*_matching)[n] = INVALID;
 		        (*_status)[n] = UNMATCHED;
+		      }
@@ -479,4 +479,4 @@
 		          if ((*_matching)[u] != INVALID) return false;
 		          _matching->set(u, _graph.direct(e, true));
 		          _status->set(u, MATCHED);
 		          (*_matching)[u] = _graph.direct(e, true);
 		          (*_status)[u] = MATCHED;
@@ -484,4 +484,4 @@
 		          if ((*_matching)[v] != INVALID) return false;
 		          _matching->set(v, _graph.direct(e, false));
 		          _status->set(v, MATCHED);
 		          (*_matching)[v] = _graph.direct(e, false);
 		          (*_status)[v] = MATCHED;
+		        }
@@ -499,3 +499,3 @@
 		          _tree_set->insert(n);
-		          _status->set(n, EVEN);
+		          (*_status)[n] = EVEN;
 		          processSparse(n);
@@ -514,3 +514,3 @@
 		          _tree_set->insert(n);
-		          _status->set(n, EVEN);
+		          (*_status)[n] = EVEN;
 		          processDense(n);
@@ -1550,5 +1550,5 @@
-		        _matching->set(base, matching);
+		        (*_matching)[base] = matching;
 		        _blossom_node_list.push_back(base);
-		        _node_potential->set(base, pot);
+		        (*_node_potential)[base] = pot;
 		      } else {
@@ -1646,13 +1646,13 @@
 		      for (ArcIt e(_graph); e != INVALID; ++e) {
-		        _node_heap_index->set(e, BinHeap<Value, IntArcMap>::PRE_HEAP);
+		        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
+		      }
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
-		        _delta1_index->set(n, _delta1->PRE_HEAP);
+		        (*_delta1_index)[n] = _delta1->PRE_HEAP;
+		      }
 		      for (EdgeIt e(_graph); e != INVALID; ++e) {
-		        _delta3_index->set(e, _delta3->PRE_HEAP);
+		        (*_delta3_index)[e] = _delta3->PRE_HEAP;
+		      }
 		      for (int i = 0; i < _blossom_num; ++i) {
 		        _delta2_index->set(i, _delta2->PRE_HEAP);
 		        _delta4_index->set(i, _delta4->PRE_HEAP);
 		        (*_delta2_index)[i] = _delta2->PRE_HEAP;
 		        (*_delta4_index)[i] = _delta4->PRE_HEAP;
+		      }
@@ -1668,3 +1668,3 @@
+		        }
-		        _node_index->set(n, index);
+		        (*_node_index)[n] = index;
 		        (*_node_data)[index].pot = max;
@@ -2743,5 +2743,5 @@
-		        _matching->set(base, matching);
+		        (*_matching)[base] = matching;
 		        _blossom_node_list.push_back(base);
-		        _node_potential->set(base, pot);
+		        (*_node_potential)[base] = pot;
 		      } else {
@@ -2833,10 +2833,10 @@
 		      for (ArcIt e(_graph); e != INVALID; ++e) {
-		        _node_heap_index->set(e, BinHeap<Value, IntArcMap>::PRE_HEAP);
+		        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
+		      }
 		      for (EdgeIt e(_graph); e != INVALID; ++e) {
-		        _delta3_index->set(e, _delta3->PRE_HEAP);
+		        (*_delta3_index)[e] = _delta3->PRE_HEAP;
+		      }
 		      for (int i = 0; i < _blossom_num; ++i) {
 		        _delta2_index->set(i, _delta2->PRE_HEAP);
 		        _delta4_index->set(i, _delta4->PRE_HEAP);
 		        (*_delta2_index)[i] = _delta2->PRE_HEAP;
 		        (*_delta4_index)[i] = _delta4->PRE_HEAP;
+		      }
@@ -2852,3 +2852,3 @@
+		        }
-		        _node_index->set(n, index);
+		        (*_node_index)[n] = index;
 		        (*_node_data)[index].pot = max;

lemon/min_cost_arborescence.h

Show inline comments

@@ -295,3 +295,3 @@
+		      }
-		      _arc_order->set(minimum.arc, _dual_variables.size());
+		      (*_arc_order)[minimum.arc] = _dual_variables.size();
 		      DualVariable var(_dual_node_list.size() - 1,
@@ -337,3 +337,3 @@
+		      }
-		      _arc_order->set(minimum.arc, _dual_variables.size());
+		      (*_arc_order)[minimum.arc] = _dual_variables.size();
 		      DualVariable var(node_bottom, _dual_node_list.size(), minimum.value);
@@ -366,3 +366,3 @@
 		        _heap->pop();
-		        _node_order->set(source, -1);
+		        (*_node_order)[source] = -1;
 		        for (OutArcIt it(*_digraph, source); it != INVALID; ++it) {
@@ -652,4 +652,4 @@
 		        (*_cost_arcs)[it].arc = INVALID;
 		        _node_order->set(it, -3);
 		        _heap_cross_ref->set(it, Heap::PRE_HEAP);
 		        (*_node_order)[it] = -3;
 		        (*_heap_cross_ref)[it] = Heap::PRE_HEAP;
 		        _pred->set(it, INVALID);
@@ -658,3 +658,3 @@
 		        _arborescence->set(it, false);
-		        _arc_order->set(it, -1);
+		        (*_arc_order)[it] = -1;
+		      }

lemon/preflow.h

Show inline comments

@@ -406,3 +406,3 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
-		        _excess->set(n, 0);
+		        (*_excess)[n] = 0;
+		      }
@@ -419,6 +419,6 @@
 		      std::vector<Node> queue;
-		      reached.set(_source, true);
+		      reached[_source] = true;
 		      queue.push_back(_target);
-		      reached.set(_target, true);
+		      reached[_target] = true;
 		      while (!queue.empty()) {
@@ -431,3 +431,3 @@
 		            if (!reached[u] && _tolerance.positive((*_capacity)[e])) {
-		              reached.set(u, true);
+		              reached[u] = true;
 		              _level->initAddItem(u);
@@ -446,3 +446,3 @@
 		          _flow->set(e, (*_capacity)[e]);
-		          _excess->set(u, (*_excess)[u] + (*_capacity)[e]);
+		          (*_excess)[u] += (*_capacity)[e];
 		          if (u != _target && !_level->active(u)) {
@@ -480,3 +480,3 @@
 		        if (excess < 0 && n != _source) return false;
-		        _excess->set(n, excess);
+		        (*_excess)[n] = excess;
+		      }
@@ -489,6 +489,6 @@
 		      std::vector<Node> queue;
-		      reached.set(_source, true);
+		      reached[_source] = true;
 		      queue.push_back(_target);
-		      reached.set(_target, true);
+		      reached[_target] = true;
 		      while (!queue.empty()) {
@@ -502,3 +502,3 @@
 		                _tolerance.positive((*_capacity)[e] - (*_flow)[e])) {
-		              reached.set(u, true);
+		              reached[u] = true;
 		              _level->initAddItem(u);
@@ -510,3 +510,3 @@
 		            if (!reached[v] && _tolerance.positive((*_flow)[e])) {
-		              reached.set(v, true);
+		              reached[v] = true;
 		              _level->initAddItem(v);
@@ -526,3 +526,3 @@
 		          _flow->set(e, (*_capacity)[e]);
-		          _excess->set(u, (*_excess)[u] + rem);
+		          (*_excess)[u] += rem;
 		          if (u != _target && !_level->active(u)) {
@@ -538,3 +538,3 @@
 		          _flow->set(e, 0);
-		          _excess->set(v, (*_excess)[v] + rem);
+		          (*_excess)[v] += rem;
 		          if (v != _target && !_level->active(v)) {
@@ -579,3 +579,3 @@
 		                _flow->set(e, (*_flow)[e] + excess);
-		                _excess->set(v, (*_excess)[v] + excess);
+		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -584,3 +584,3 @@
 		                excess -= rem;
-		                _excess->set(v, (*_excess)[v] + rem);
+		                (*_excess)[v] += rem;
 		                _flow->set(e, (*_capacity)[e]);
@@ -602,3 +602,3 @@
 		                _flow->set(e, (*_flow)[e] - excess);
-		                _excess->set(v, (*_excess)[v] + excess);
+		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -607,3 +607,3 @@
 		                excess -= rem;
-		                _excess->set(v, (*_excess)[v] + rem);
+		                (*_excess)[v] += rem;
 		                _flow->set(e, 0);
@@ -617,3 +617,3 @@
-		          _excess->set(n, excess);
+		          (*_excess)[n] = excess;
@@ -652,3 +652,3 @@
 		                _flow->set(e, (*_flow)[e] + excess);
-		                _excess->set(v, (*_excess)[v] + excess);
+		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -657,3 +657,3 @@
 		                excess -= rem;
-		                _excess->set(v, (*_excess)[v] + rem);
+		                (*_excess)[v] += rem;
 		                _flow->set(e, (*_capacity)[e]);
@@ -675,3 +675,3 @@
 		                _flow->set(e, (*_flow)[e] - excess);
-		                _excess->set(v, (*_excess)[v] + excess);
+		                (*_excess)[v] += excess;
 		                excess = 0;
@@ -680,3 +680,3 @@
 		                excess -= rem;
-		                _excess->set(v, (*_excess)[v] + rem);
+		                (*_excess)[v] += rem;
 		                _flow->set(e, 0);
@@ -690,3 +690,3 @@
-		          _excess->set(n, excess);
+		          (*_excess)[n] = excess;
@@ -733,3 +733,3 @@
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
-		        reached.set(n, (*_level)[n] < _level->maxLevel());
+		        reached[n] = (*_level)[n] < _level->maxLevel();
+		      }
@@ -741,3 +741,3 @@
 		      queue.push_back(_source);
-		      reached.set(_source, true);
+		      reached[_source] = true;
@@ -751,3 +751,3 @@
 		            if (!reached[v] && _tolerance.positive((*_flow)[e])) {
-		              reached.set(v, true);
+		              reached[v] = true;
 		              _level->initAddItem(v);
@@ -760,3 +760,3 @@
 		                _tolerance.positive((*_capacity)[e] - (*_flow)[e])) {
-		              reached.set(u, true);
+		              reached[u] = true;
 		              _level->initAddItem(u);
@@ -794,3 +794,3 @@
 		              _flow->set(e, (*_flow)[e] + excess);
-		              _excess->set(v, (*_excess)[v] + excess);
+		              (*_excess)[v] += excess;
 		              excess = 0;
@@ -799,3 +799,3 @@
 		              excess -= rem;
-		              _excess->set(v, (*_excess)[v] + rem);
+		              (*_excess)[v] += rem;
 		              _flow->set(e, (*_capacity)[e]);
@@ -817,3 +817,3 @@
 		              _flow->set(e, (*_flow)[e] - excess);
-		              _excess->set(v, (*_excess)[v] + excess);
+		              (*_excess)[v] += excess;
 		              excess = 0;
@@ -822,3 +822,3 @@
 		              excess -= rem;
-		              _excess->set(v, (*_excess)[v] + rem);
+		              (*_excess)[v] += rem;
 		              _flow->set(e, 0);
@@ -832,3 +832,3 @@
-		        _excess->set(n, excess);
+		        (*_excess)[n] = excess;

test/kruskal_test.cc

Show inline comments

@@ -101,12 +101,12 @@
 		  edge_cost_map.set(e1, -10);
 		  edge_cost_map.set(e2, -9);
 		  edge_cost_map.set(e3, -8);
 		  edge_cost_map.set(e4, -7);
 		  edge_cost_map.set(e5, -6);
 		  edge_cost_map.set(e6, -5);
 		  edge_cost_map.set(e7, -4);
 		  edge_cost_map.set(e8, -3);
 		  edge_cost_map.set(e9, -2);
 		  edge_cost_map.set(e10, -1);
 		  edge_cost_map[e1] = -10;
 		  edge_cost_map[e2] = -9;
 		  edge_cost_map[e3] = -8;
 		  edge_cost_map[e4] = -7;
 		  edge_cost_map[e5] = -6;
 		  edge_cost_map[e6] = -5;
 		  edge_cost_map[e7] = -4;
 		  edge_cost_map[e8] = -3;
 		  edge_cost_map[e9] = -2;
 		  edge_cost_map[e10] = -1;

0 comments (0 inline)

RhodeCode

Login to your account