mirror of
https://github.com/Z3Prover/z3
synced 2025-04-14 04:48:45 +00:00
127 lines
3.4 KiB
C++
127 lines
3.4 KiB
C++
/*++
|
|
Copyright (c) 2017 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
<name>
|
|
|
|
Abstract:
|
|
|
|
<abstract>
|
|
|
|
Author:
|
|
|
|
Lev Nachmanson (levnach)
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
#pragma once
|
|
|
|
#include <set>
|
|
#include "math/lp/lp_utils.h"
|
|
#include "math/lp/binary_heap_upair_queue.h"
|
|
namespace lp {
|
|
template <typename T> binary_heap_upair_queue<T>::binary_heap_upair_queue(unsigned size) : m_q(size), m_pairs(size) {
|
|
for (unsigned i = 0; i < size; i++)
|
|
m_available_spots.push_back(i);
|
|
}
|
|
|
|
template <typename T> unsigned
|
|
binary_heap_upair_queue<T>::dequeue_available_spot() {
|
|
lp_assert(m_available_spots.empty() == false);
|
|
unsigned ret = m_available_spots.back();
|
|
m_available_spots.pop_back();
|
|
return ret;
|
|
}
|
|
|
|
template <typename T> void binary_heap_upair_queue<T>::remove(unsigned i, unsigned j) {
|
|
upair p(i, j);
|
|
auto it = m_pairs_to_index.find(p);
|
|
if (it == m_pairs_to_index.end())
|
|
return; // nothing to do
|
|
m_q.remove(it->second);
|
|
m_available_spots.push_back(it->second);
|
|
m_pairs_to_index.erase(it);
|
|
}
|
|
|
|
|
|
template <typename T> bool binary_heap_upair_queue<T>::ij_index_is_new(unsigned ij_index) const {
|
|
for (auto it : m_pairs_to_index) {
|
|
if (it.second == ij_index)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename T> void binary_heap_upair_queue<T>::enqueue(unsigned i, unsigned j, const T & priority) {
|
|
upair p(i, j);
|
|
auto it = m_pairs_to_index.find(p);
|
|
unsigned ij_index;
|
|
if (it == m_pairs_to_index.end()) {
|
|
// it is a new pair, let us find a spot for it
|
|
if (m_available_spots.empty()) {
|
|
// we ran out of empty spots
|
|
unsigned size_was = static_cast<unsigned>(m_pairs.size());
|
|
unsigned new_size = size_was << 1;
|
|
for (unsigned i = size_was; i < new_size; i++)
|
|
m_available_spots.push_back(i);
|
|
m_pairs.resize(new_size);
|
|
}
|
|
ij_index = dequeue_available_spot();
|
|
// lp_assert(ij_index<m_pairs.size() && ij_index_is_new(ij_index));
|
|
m_pairs[ij_index] = p;
|
|
m_pairs_to_index[p] = ij_index;
|
|
} else {
|
|
ij_index = it->second;
|
|
}
|
|
m_q.enqueue(ij_index, priority);
|
|
}
|
|
|
|
template <typename T> void binary_heap_upair_queue<T>::dequeue(unsigned & i, unsigned &j) {
|
|
lp_assert(!m_q.is_empty());
|
|
unsigned ij_index = m_q.dequeue();
|
|
upair & p = m_pairs[ij_index];
|
|
i = p.first;
|
|
j = p.second;
|
|
m_available_spots.push_back(ij_index);
|
|
m_pairs_to_index.erase(p);
|
|
}
|
|
|
|
|
|
template <typename T> T binary_heap_upair_queue<T>::get_priority(unsigned i, unsigned j) const {
|
|
auto it = m_pairs_to_index.find(std::make_pair(i, j));
|
|
if (it == m_pairs_to_index.end())
|
|
return T(0xFFFFFF); // big number
|
|
return m_q.get_priority(it->second);
|
|
}
|
|
|
|
#ifdef Z3DEBUG
|
|
template <typename T> bool binary_heap_upair_queue<T>::pair_to_index_is_a_bijection() const {
|
|
std::set<int> tmp;
|
|
for (auto p : m_pairs_to_index) {
|
|
unsigned j = p.second;
|
|
unsigned size = tmp.size();
|
|
tmp.insert(j);
|
|
if (tmp.size() == size)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <typename T> bool binary_heap_upair_queue<T>::available_spots_are_correct() const {
|
|
std::set<int> tmp;
|
|
for (auto p : m_available_spots){
|
|
tmp.insert(p);
|
|
}
|
|
if (tmp.size() != m_available_spots.size())
|
|
return false;
|
|
for (auto it : m_pairs_to_index)
|
|
if (tmp.find(it.second) != tmp.end())
|
|
return false;
|
|
return true;
|
|
}
|
|
#endif
|
|
}
|