lemon-1.3: comparison lemon/elevator.h

equal deleted inserted replaced

-:25c16650089f
+:8347d666473c
 int _highest_active;
 void copy(Item i, Vit p)
 {
-_where.set(*p=i,p);
+_where[*p=i] = p;
 }
 void copy(Vit s, Vit p)
 {
 if(s!=p)
 {
 Item i=*s;
 *p=i;
-_where.set(i,p);
+_where[i] = p;
 }
 }
 void swap(Vit i, Vit j)
 {
 Item ti=*i;
 Vit ct = _where[ti];
-_where.set(ti,_where[*i=*j]);
+_where[ti] = _where[*i=*j];
-_where.set(*j,ct);
+_where[*j] = ct;
 *j=ti;
 }
 public:
 ///Lift the item returned by highestActive() by one.
 ///
 void liftHighestActive()
 {
 Item it = *_last_active[_highest_active];
-_level.set(it,_level[it]+1);
+++_level[it];
 swap(_last_active[_highest_active]--,_last_active[_highest_active+1]);
 --_first[++_highest_active];
 }
 ///Lift the highest active item to the given level.
 {
 copy(--_first[l+1],_first[l]);
 --_last_active[l];
 }
 copy(li,_first[new_level]);
-_level.set(li,new_level);
+_level[li] = new_level;
 _highest_active=new_level;
 }
 ///Lift the highest active item to the top level.
 copy(--_first[l+1],_first[l]);
 --_last_active[l];
 }
 copy(li,_first[_max_level]);
 --_last_active[_max_level];
-_level.set(li,_max_level);
+_level[li] = _max_level;
 while(_highest_active>=0 &&
 _last_active[_highest_active]<_first[_highest_active])
 _highest_active--;
 }
 ///Lift the active item returned by \ref activeOn() "activeOn(level)"
 ///by one.
 Item liftActiveOn(int level)
 {
 Item it =*_last_active[level];
-_level.set(it,_level[it]+1);
+++_level[it];
 swap(_last_active[level]--, --_first[level+1]);
 if (level+1>_highest_active) ++_highest_active;
 }
 ///Lift the active item returned by \c activeOn(level) to the given level.
 {
 copy(_last_active[l],_first[l]);
 copy(--_first[l+1], _last_active[l]--);
 }
 copy(ai,_first[new_level]);
-_level.set(ai,new_level);
+_level[ai] = new_level;
 if (new_level>_highest_active) _highest_active=new_level;
 }
 ///Lift the active item returned by \c activeOn(level) to the top level.
 copy(_last_active[l],_first[l]);
 copy(--_first[l+1], _last_active[l]--);
 }
 copy(ai,_first[_max_level]);
 --_last_active[_max_level];
-_level.set(ai,_max_level);
+_level[ai] = _max_level;
 if (_highest_active==level) {
 while(_highest_active>=0 &&
 _last_active[_highest_active]<_first[_highest_active])
 _highest_active--;
 {
 copy(_last_active[l],_first[l]);
 copy(--_first[l+1],_last_active[l]--);
 }
 copy(i,_first[new_level]);
-_level.set(i,new_level);
+_level[i] = new_level;
 if(new_level>_highest_active) _highest_active=new_level;
 }
 ///Move an inactive item to the top but one level (in a dirty way).
 ///but one level (in a dirty way).
 ///\warning It makes the underlying datastructure corrupt, so use it
 ///only if you really know what it is for.
 ///\pre The item is on the top level.
 void dirtyTopButOne(Item i) {
-_level.set(i,_max_level - 1);
+_level[i] = _max_level - 1;
 }
 ///Lift all items on and above the given level to the top level.
 ///This function lifts all items on and above level \c l to the top
 void liftToTop(int l)
 {
 const Vit f=_first[l];
 const Vit tl=_first[_max_level];
 for(Vit i=f;i!=tl;++i)
-_level.set(*i,_max_level);
+_level[*i] = _max_level;
 for(int i=l;i<=_max_level;i++)
 {
 _first[i]=f;
 _last_active[i]=f-1;
 }
 _last_active[0]=&_items[0]-1;
 Vit n=&_items[0];
 for(typename ItemSetTraits<GR,Item>::ItemIt i(_g);i!=INVALID;++i)
 {
 *n=i;
-_where.set(i,n);
+_where[i] = n;
-_level.set(i,_max_level);
+_level[i] = _max_level;
 ++n;
 }
 }
 ///Add an item to the current level.
 void initAddItem(Item i)
 {
 swap(_where[i],_init_num);
-_level.set(i,_init_lev);
+_level[i] = _init_lev;
 ++_init_num;
 }
 ///Start a new level.
 ///Activate item \c i.
 ///Activate item \c i.
 ///\pre Item \c i shouldn't be active before.
 void activate(Item i) {
-_active.set(i, true);
+_active[i] = true;
 int level = _level[i];
 if (level > _highest_active) {
 _highest_active = level;
 }
 if (_prev[i] == INVALID || _active[_prev[i]]) return;
 //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 {
 _last[level] = _prev[i];
 }
 //lace
-_next.set(i, _first[level]);
+_next[i] = _first[level];
-_prev.set(_first[level], i);
+_prev[_first[level]] = i;
-_prev.set(i, INVALID);
+_prev[i] = INVALID;
 _first[level] = i;
 }
 ///Deactivate item \c i.
 ///Deactivate item \c i.
 ///\pre Item \c i must be active before.
 void deactivate(Item i) {
-_active.set(i, false);
+_active[i] = false;
 int level = _level[i];
 if (_next[i] == INVALID || !_active[_next[i]])
 goto find_highest_level;
 //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 {
 _first[_level[i]] = _next[i];
 }
 //lace
-_prev.set(i, _last[level]);
+_prev[i] = _last[level];
-_next.set(_last[level], i);
+_next[_last[level]] = i;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 _last[level] = i;
 find_highest_level:
 if (level == _highest_active) {
 while (_highest_active >= 0 && activeFree(_highest_active))
 ///Lift the item returned by highestActive() by one.
 ///
 void liftHighestActive() {
 Item i = _first[_highest_active];
 if (_next[i] != INVALID) {
-_prev.set(_next[i], INVALID);
+_prev[_next[i]] = INVALID;
 _first[_highest_active] = _next[i];
 } else {
 _first[_highest_active] = INVALID;
 _last[_highest_active] = INVALID;
 }
-_level.set(i, ++_highest_active);
+_level[i] = ++_highest_active;
 if (_first[_highest_active] == INVALID) {
 _first[_highest_active] = i;
 _last[_highest_active] = i;
-_prev.set(i, INVALID);
+_prev[i] = INVALID;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 } else {
-_prev.set(_first[_highest_active], i);
+_prev[_first[_highest_active]] = i;
-_next.set(i, _first[_highest_active]);
+_next[i] = _first[_highest_active];
 _first[_highest_active] = i;
 }
 }
 ///Lift the highest active item to the given level.
 ///than the current level.
 ///
 void liftHighestActive(int new_level) {
 Item i = _first[_highest_active];
 if (_next[i] != INVALID) {
-_prev.set(_next[i], INVALID);
+_prev[_next[i]] = INVALID;
 _first[_highest_active] = _next[i];
 } else {
 _first[_highest_active] = INVALID;
 _last[_highest_active] = INVALID;
 }
-_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);
+_prev[i] = INVALID;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 } else {
-_prev.set(_first[_highest_active], i);
+_prev[_first[_highest_active]] = i;
-_next.set(i, _first[_highest_active]);
+_next[i] = _first[_highest_active];
 _first[_highest_active] = i;
 }
 }
 ///Lift the highest active item to the top level.
 ///Lift the item returned by highestActive() to the top level and
 ///deactivate it.
 void liftHighestActiveToTop() {
 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];
 } else {
 _first[_highest_active] = INVALID;
 _last[_highest_active] = INVALID;
 }
 ///by one.
 Item liftActiveOn(int l)
 {
 Item i = _first[l];
 if (_next[i] != INVALID) {
-_prev.set(_next[i], INVALID);
+_prev[_next[i]] = INVALID;
 _first[l] = _next[i];
 } else {
 _first[l] = INVALID;
 _last[l] = INVALID;
 }
-_level.set(i, ++l);
+_level[i] = ++l;
 if (_first[l] == INVALID) {
 _first[l] = _last[l] = i;
-_prev.set(i, INVALID);
+_prev[i] = INVALID;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 } else {
-_prev.set(_first[l], i);
+_prev[_first[l]] = i;
-_next.set(i, _first[l]);
+_next[i] = _first[l];
 _first[l] = i;
 }
 if (_highest_active < l) {
 _highest_active = l;
 }
 ///to the given level.
 void liftActiveOn(int l, int new_level)
 {
 Item i = _first[l];
 if (_next[i] != INVALID) {
-_prev.set(_next[i], INVALID);
+_prev[_next[i]] = INVALID;
 _first[l] = _next[i];
 } else {
 _first[l] = INVALID;
 _last[l] = INVALID;
 }
-_level.set(i, l = new_level);
+_level[i] = l = new_level;
 if (_first[l] == INVALID) {
 _first[l] = _last[l] = i;
-_prev.set(i, INVALID);
+_prev[i] = INVALID;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 } else {
-_prev.set(_first[l], i);
+_prev[_first[l]] = i;
-_next.set(i, _first[l]);
+_next[i] = _first[l];
 _first[l] = i;
 }
 if (_highest_active < l) {
 _highest_active = l;
 }
 ///to the top level and deactivate it.
 void liftActiveToTop(int l)
 {
 Item i = _first[l];
 if (_next[i] != INVALID) {
-_prev.set(_next[i], INVALID);
+_prev[_next[i]] = INVALID;
 _first[l] = _next[i];
 } else {
 _first[l] = INVALID;
 _last[l] = INVALID;
 }
-_level.set(i, _max_level);
+_level[i] = _max_level;
 if (l == _highest_active) {
 while (_highest_active >= 0 && activeFree(_highest_active))
 --_highest_active;
 }
 }
 /// \param new_level The new level of \c i. It must be strictly higher
 /// than the current level.
 ///
 void lift(Item i, int new_level) {
 if (_next[i] != INVALID) {
-_prev.set(_next[i], _prev[i]);
+_prev[_next[i]] = _prev[i];
 } else {
 _last[new_level] = _prev[i];
 }
 if (_prev[i] != INVALID) {
-_next.set(_prev[i], _next[i]);
+_next[_prev[i]] = _next[i];
 } else {
 _first[new_level] = _next[i];
 }
-_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);
+_prev[i] = INVALID;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 } else {
-_prev.set(_first[new_level], i);
+_prev[_first[new_level]] = i;
-_next.set(i, _first[new_level]);
+_next[i] = _first[new_level];
 _first[new_level] = i;
 }
 if (_highest_active < new_level) {
 _highest_active = new_level;
 }
 ///but one level (in a dirty way).
 ///\warning It makes the underlying datastructure corrupt, so use it
 ///only if you really know what it is for.
 ///\pre The item is on the top level.
 void dirtyTopButOne(Item i) {
-_level.set(i, _max_level - 1);
+_level[i] = _max_level - 1;
 }
 ///Lift all items on and above the given level to the top level.
 ///This function lifts all items on and above level \c l to the top
 ///level and deactivates them.
 void liftToTop(int l)  {
 for (int i = l + 1; _first[i] != INVALID; ++i) {
 Item n = _first[i];
 while (n != INVALID) {
-_level.set(n, _max_level);
+_level[n] = _max_level;
 n = _next[n];
 }
 _first[i] = INVALID;
 _last[i] = INVALID;
 }
 _first[i] = _last[i] = INVALID;
 }
 _init_level = 0;
 for(typename ItemSetTraits<GR,Item>::ItemIt i(_graph);
 i != INVALID; ++i) {
-_level.set(i, _max_level);
+_level[i] = _max_level;
-_active.set(i, false);
+_active[i] = false;
 }
 }
 ///Add an item to the current level.
 void initAddItem(Item i) {
-_level.set(i, _init_level);
+_level[i] = _init_level;
 if (_last[_init_level] == INVALID) {
 _first[_init_level] = i;
 _last[_init_level] = i;
-_prev.set(i, INVALID);
+_prev[i] = INVALID;
-_next.set(i, INVALID);
+_next[i] = INVALID;
 } else {
-_prev.set(i, _last[_init_level]);
+_prev[i] = _last[_init_level];
-_next.set(i, INVALID);
+_next[i] = INVALID;
-_next.set(_last[_init_level], i);
+_next[_last[_init_level]] = i;
 _last[_init_level] = i;
 }
 }
 ///Start a new level.

changeset 595	16d7255a6849
parent 559	c5fd2d996909
child 1139	d51126dc39fa