inline void balance(std::vector<ext_task>& tasks, std::vector<std::vector<ext_task> >& sched) { int size = sched.size(); int n = tasks.size(); std::sort(tasks.begin(), tasks.end()); typedef boost::heap::fibonacci_heap<heap_node> heap_type; std::vector<heap_type::handle_type> Sh(size); heap_type S; int lim = std::min(size, n); // initialize heap for (int i = 0; i < lim; ++i) { sched[i].push_back(tasks.back()); Sh[i] = S.push(heap_node(i, tasks.back().t.cost)); tasks.pop_back(); } // update heap (and schedule) for (int i = 0; i < n - lim; ++i) { heap_node nd = S.top(); sched[nd.pos].push_back(tasks.back()); nd.cost += tasks.back().t.cost; S.update(Sh[nd.pos], nd); tasks.pop_back(); } } // balance
void matcher::heap::push(int u, int v) { int pos = heap_pos[u][v]; if (pos <= len && nodes[pos].u == u && nodes[pos].v == v) return; nodes[++len] = heap_node(u, v); heap_pos[u][v] = len; heap_up(len); }
matcher::heap::heap(int n, int m, class matcher *o) { owner = o; len = 0; memset(heap_pos, 0, sizeof(heap_pos)); for (int i=1; i<=n; i++) for (int j=1; j<=m; j++){ heap_pos[i][j] = ++len; nodes[len] = heap_node(i, j); } for (int i=len/2; i>0; i--) heap_down(i); }
matcher::heap::heap(map <int, double> *weights, int n, class matcher *o) { owner = o; len = 0; for (int i=1; i<=n; i++){ for (std::map<int, double> ::iterator it=weights[i].begin(); it != weights[i].end(); it++) { heap_pos[i][it->first] = ++len; nodes[len] = heap_node(i, it->first); } } for (int i=len/2; i>0; i--) heap_down(i); }
// juergen: added 26 July, 2002 size_t CIndexedPriorityQueue::insertStochReaction(const size_t index, const C_FLOAT64 key) { size_t pos; // check if index is valid if (index >= mIndexPointer.size()) return - 1; // first the node is inserted at the end of the heap mIndexPointer[index] = mHeap.size(); PQNode heap_node(index, key); mHeap.push_back(heap_node); // bubble the node up the tree to the right position ! pos = mIndexPointer[index]; while ((pos > 0) && (mHeap[parent(pos)].mKey > key)) { swapNodes(pos, parent(pos)); pos = parent(pos); } return 0; }
size_t CIndexedPriorityQueue::pushPair(const size_t index, const C_FLOAT64 key) { // Add an element to the priority queue. This merely pushes an item onto // the back of the vector corresponding to the heap, and pushes the index // onto the back of the vector corresponding to the index structure. // Implicit is the assumption that this is done in contiguous ascending order // for the index; i.e. in index order 0,1,2,3... // N.B. The structures are not yet ordered as an indexed priority queue; this must // be done using the buildHeap() method // First check that the index corresponds to the heap size before insertion if (static_cast<unsigned int>(index) != mHeap.size()) { CCopasiMessage(CCopasiMessage::ERROR, "Error inserting pair into priority queue"); return - 1; } PQNode heap_node(index, key); mHeap.push_back(heap_node); // at first, position == index size_t position = index; // for clarity mIndexPointer.push_back(position); return 0; }