lemon-1.1: comparison lemon/max

equal deleted inserted replaced

-:99828e8cc26c
+:68d165361847
 Node node = _graph.u(e);
 Arc arc = _graph.direct(e, true);
 Node base = (*_blossom_rep)[_blossom_set->find(node)];
 while (base != nca) {
-_ear->set(node, arc);
+(*_ear)[node] = arc;
 Node n = node;
 while (n != base) {
 n = _graph.target((*_matching)[n]);
 Arc a = (*_ear)[n];
 n = _graph.target(a);
-_ear->set(n, _graph.oppositeArc(a));
+(*_ear)[n] = _graph.oppositeArc(a);
 }
 node = _graph.target((*_matching)[base]);
 _tree_set->erase(base);
 _tree_set->erase(node);
 _blossom_set->insert(node, _blossom_set->find(base));
-_status->set(node, EVEN);
+(*_status)[node] = EVEN;
 _node_queue[_last++] = node;
 arc = _graph.oppositeArc((*_ear)[node]);
 node = _graph.target((*_ear)[node]);
 base = (*_blossom_rep)[_blossom_set->find(node)];
 _blossom_set->join(_graph.target(arc), base);
 }
 }
-_blossom_rep->set(_blossom_set->find(nca), nca);
+(*_blossom_rep)[_blossom_set->find(nca)] = nca;
 {
 Node node = _graph.v(e);
 Arc arc = _graph.direct(e, false);
 Node base = (*_blossom_rep)[_blossom_set->find(node)];
 while (base != nca) {
-_ear->set(node, arc);
+(*_ear)[node] = arc;
 Node n = node;
 while (n != base) {
 n = _graph.target((*_matching)[n]);
 Arc a = (*_ear)[n];
 n = _graph.target(a);
-_ear->set(n, _graph.oppositeArc(a));
+(*_ear)[n] = _graph.oppositeArc(a);
 }
 node = _graph.target((*_matching)[base]);
 _tree_set->erase(base);
 _tree_set->erase(node);
 _blossom_set->insert(node, _blossom_set->find(base));
-_status->set(node, EVEN);
+(*_status)[node] = EVEN;
 _node_queue[_last++] = node;
 arc = _graph.oppositeArc((*_ear)[node]);
 node = _graph.target((*_ear)[node]);
 base = (*_blossom_rep)[_blossom_set->find(node)];
 _blossom_set->join(_graph.target(arc), base);
 }
 }
-_blossom_rep->set(_blossom_set->find(nca), nca);
+(*_blossom_rep)[_blossom_set->find(nca)] = nca;
 }
 void extendOnArc(const Arc& a) {
 Node base = _graph.source(a);
 Node odd = _graph.target(a);
-_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);
+(*_blossom_rep)[_blossom_set->insert(even)] = even;
-_status->set(odd, ODD);
+(*_status)[odd] = ODD;
-_status->set(even, EVEN);
+(*_status)[even] = EVEN;
 int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(base)]);
 _tree_set->insert(odd, tree);
 _tree_set->insert(even, tree);
 _node_queue[_last++] = even;
 Node even = _graph.source(a);
 Node odd = _graph.target(a);
 int tree = _tree_set->find((*_blossom_rep)[_blossom_set->find(even)]);
-_matching->set(odd, _graph.oppositeArc(a));
+(*_matching)[odd] = _graph.oppositeArc(a);
-_status->set(odd, MATCHED);
+(*_status)[odd] = MATCHED;
 Arc arc = (*_matching)[even];
-_matching->set(even, a);
+(*_matching)[even] = a;
 while (arc != INVALID) {
 odd = _graph.target(arc);
 arc = (*_ear)[odd];
 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]);
 }
 for (typename TreeSet::ItemIt it(*_tree_set, tree);
 it != INVALID; ++it) {
 if ((*_status)[it] == ODD) {
-_status->set(it, MATCHED);
+(*_status)[it] = MATCHED;
 } else {
 int blossom = _blossom_set->find(it);
 for (typename BlossomSet::ItemIt jt(*_blossom_set, blossom);
 jt != INVALID; ++jt) {
-_status->set(jt, MATCHED);
+(*_status)[jt] = MATCHED;
 }
 _blossom_set->eraseClass(blossom);
 }
 }
 _tree_set->eraseClass(tree);
 /// Sets the actual matching to the empty matching.
 ///
 void init() {
 createStructures();
 for(NodeIt n(_graph); n != INVALID; ++n) {
-_matching->set(n, INVALID);
+(*_matching)[n] = INVALID;
-_status->set(n, UNMATCHED);
+(*_status)[n] = UNMATCHED;
 }
 }
 ///\brief Finds an initial matching in a greedy way
 ///
 ///It finds an initial matching in a greedy way.
 void greedyInit() {
 createStructures();
 for (NodeIt n(_graph); n != INVALID; ++n) {
-_matching->set(n, INVALID);
+(*_matching)[n] = INVALID;
-_status->set(n, UNMATCHED);
+(*_status)[n] = UNMATCHED;
 }
 for (NodeIt n(_graph); n != INVALID; ++n) {
 if ((*_matching)[n] == INVALID) {
 for (OutArcIt a(_graph, n); a != INVALID ; ++a) {
 Node v = _graph.target(a);
 if ((*_matching)[v] == INVALID && v != n) {
-_matching->set(n, a);
+(*_matching)[n] = a;
-_status->set(n, MATCHED);
+(*_status)[n] = MATCHED;
-_matching->set(v, _graph.oppositeArc(a));
+(*_matching)[v] = _graph.oppositeArc(a);
-_status->set(v, MATCHED);
+(*_status)[v] = MATCHED;
 break;
 }
 }
 }
 }
 template <typename MatchingMap>
 bool matchingInit(const MatchingMap& matching) {
 createStructures();
 for (NodeIt n(_graph); n != INVALID; ++n) {
-_matching->set(n, INVALID);
+(*_matching)[n] = INVALID;
-_status->set(n, UNMATCHED);
+(*_status)[n] = UNMATCHED;
 }
 for(EdgeIt e(_graph); e!=INVALID; ++e) {
 if (matching[e]) {
 Node u = _graph.u(e);
 if ((*_matching)[u] != INVALID) return false;
-_matching->set(u, _graph.direct(e, true));
+(*_matching)[u] = _graph.direct(e, true);
-_status->set(u, MATCHED);
+(*_status)[u] = MATCHED;
 Node v = _graph.v(e);
 if ((*_matching)[v] != INVALID) return false;
-_matching->set(v, _graph.direct(e, false));
+(*_matching)[v] = _graph.direct(e, false);
-_status->set(v, MATCHED);
+(*_status)[v] = MATCHED;
 }
 }
 return true;
 }
 void startSparse() {
 for(NodeIt n(_graph); n != INVALID; ++n) {
 if ((*_status)[n] == UNMATCHED) {
 (*_blossom_rep)[_blossom_set->insert(n)] = n;
 _tree_set->insert(n);
-_status->set(n, EVEN);
+(*_status)[n] = EVEN;
 processSparse(n);
 }
 }
 }
 void startDense() {
 for(NodeIt n(_graph); n != INVALID; ++n) {
 if ((*_status)[n] == UNMATCHED) {
 (*_blossom_rep)[_blossom_set->insert(n)] = n;
 _tree_set->insert(n);
-_status->set(n, EVEN);
+(*_status)[n] = EVEN;
 processDense(n);
 }
 }
 }
 void extractBlossom(int blossom, const Node& base, const Arc& matching) {
 if (_blossom_set->trivial(blossom)) {
 int bi = (*_node_index)[base];
 Value pot = (*_node_data)[bi].pot;
-_matching->set(base, matching);
+(*_matching)[base] = matching;
 _blossom_node_list.push_back(base);
-_node_potential->set(base, pot);
+(*_node_potential)[base] = pot;
 } else {
 Value pot = (*_blossom_data)[blossom].pot;
 int bn = _blossom_node_list.size();
 /// Initialize the algorithm
 void init() {
 createStructures();
 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);
+(*_delta2_index)[i] = _delta2->PRE_HEAP;
-_delta4_index->set(i, _delta4->PRE_HEAP);
+(*_delta4_index)[i] = _delta4->PRE_HEAP;
 }
 int index = 0;
 for (NodeIt n(_graph); n != INVALID; ++n) {
 Value max = 0;
 if (_graph.target(e) == n) continue;
 if ((dualScale * _weight[e]) / 2 > max) {
 max = (dualScale * _weight[e]) / 2;
 }
 }
-_node_index->set(n, index);
+(*_node_index)[n] = index;
 (*_node_data)[index].pot = max;
 _delta1->push(n, max);
 int blossom =
 _blossom_set->insert(n, std::numeric_limits<Value>::max());
 void extractBlossom(int blossom, const Node& base, const Arc& matching) {
 if (_blossom_set->trivial(blossom)) {
 int bi = (*_node_index)[base];
 Value pot = (*_node_data)[bi].pot;
-_matching->set(base, matching);
+(*_matching)[base] = matching;
 _blossom_node_list.push_back(base);
-_node_potential->set(base, pot);
+(*_node_potential)[base] = pot;
 } else {
 Value pot = (*_blossom_data)[blossom].pot;
 int bn = _blossom_node_list.size();
 /// Initialize the algorithm
 void init() {
 createStructures();
 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);
+(*_delta2_index)[i] = _delta2->PRE_HEAP;
-_delta4_index->set(i, _delta4->PRE_HEAP);
+(*_delta4_index)[i] = _delta4->PRE_HEAP;
 }
 int index = 0;
 for (NodeIt n(_graph); n != INVALID; ++n) {
 Value max = - std::numeric_limits<Value>::max();
 if (_graph.target(e) == n) continue;
 if ((dualScale * _weight[e]) / 2 > max) {
 max = (dualScale * _weight[e]) / 2;
 }
 }
-_node_index->set(n, index);
+(*_node_index)[n] = index;
 (*_node_data)[index].pot = max;
 int blossom =
 _blossom_set->insert(n, std::numeric_limits<Value>::max());
 _tree_set->insert(blossom);

changeset 583	493533ead9df
parent 550	c5fd2d996909
child 582	b61354458b59