mirror of
https://github.com/Z3Prover/z3
synced 2026-02-19 15:04:42 +00:00
Standardize for-loop increments to prefix form (++i) (#8199)
* Initial plan * Convert postfix to prefix increment in for loops Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> * Fix member variable increment conversion bug Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> * Update API generator to produce prefix increments Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
This commit is contained in:
parent
851b8ea31c
commit
317dd92105
475 changed files with 3237 additions and 3237 deletions
|
|
@ -23,7 +23,7 @@ void approx_set::display(std::ostream & out) const {
|
|||
out << "{";
|
||||
bool first = true;
|
||||
unsigned long long s = m_set;
|
||||
for (unsigned i = 0; i < approx_set_traits<unsigned long long>::capacity; i++) {
|
||||
for (unsigned i = 0; i < approx_set_traits<unsigned long long>::capacity; ++i) {
|
||||
if ((s & 1) != 0) {
|
||||
if (first) {
|
||||
first = false;
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ public:
|
|||
}
|
||||
|
||||
approx_set_tpl(unsigned sz, T const * es) {
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
insert(es[i]);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ unsigned ntz_core(unsigned x) {
|
|||
*/
|
||||
unsigned ntz(unsigned sz, unsigned const * data) {
|
||||
unsigned r = 0;
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
unsigned d = data[i];
|
||||
if (d == 0)
|
||||
r += 32;
|
||||
|
|
@ -133,14 +133,14 @@ void copy(unsigned src_sz, unsigned const * src,
|
|||
unsigned dst_sz, unsigned * dst) {
|
||||
if (dst_sz >= src_sz) {
|
||||
unsigned i;
|
||||
for (i = 0; i < src_sz; i++)
|
||||
for (i = 0; i < src_sz; ++i)
|
||||
dst[i] = src[i];
|
||||
for (; i < dst_sz; i++)
|
||||
for (; i < dst_sz; ++i)
|
||||
dst[i] = 0;
|
||||
}
|
||||
else {
|
||||
SASSERT(dst_sz < src_sz);
|
||||
for (unsigned i = 0; i < dst_sz; i++)
|
||||
for (unsigned i = 0; i < dst_sz; ++i)
|
||||
dst[i] = src[i];
|
||||
}
|
||||
}
|
||||
|
|
@ -149,7 +149,7 @@ void copy(unsigned src_sz, unsigned const * src,
|
|||
\brief Return true if all words of data are zero.
|
||||
*/
|
||||
bool is_zero(unsigned sz, unsigned const * data) {
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
if (data[i])
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -159,7 +159,7 @@ bool is_zero(unsigned sz, unsigned const * data) {
|
|||
\brief Set all words of data to zero.
|
||||
*/
|
||||
void reset(unsigned sz, unsigned * data) {
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
data[i] = 0;
|
||||
}
|
||||
|
||||
|
|
@ -189,7 +189,7 @@ void shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
i = dst_sz;
|
||||
}
|
||||
else if (i < dst_sz) {
|
||||
for (unsigned r = i; r < dst_sz; r++)
|
||||
for (unsigned r = i; r < dst_sz; ++r)
|
||||
dst[r] = 0;
|
||||
}
|
||||
while (j > 0) {
|
||||
|
|
@ -203,7 +203,7 @@ void shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
if (bit_shift > 0) {
|
||||
unsigned comp_shift = (8 * sizeof(unsigned)) - bit_shift;
|
||||
unsigned prev = 0;
|
||||
for (unsigned i = word_shift; i < dst_sz; i++) {
|
||||
for (unsigned i = word_shift; i < dst_sz; ++i) {
|
||||
unsigned new_prev = (dst[i] >> comp_shift);
|
||||
dst[i] <<= bit_shift;
|
||||
dst[i] |= prev;
|
||||
|
|
@ -216,7 +216,7 @@ void shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
unsigned prev = 0;
|
||||
if (src_sz > dst_sz)
|
||||
src_sz = dst_sz;
|
||||
for (unsigned i = 0; i < src_sz; i++) {
|
||||
for (unsigned i = 0; i < src_sz; ++i) {
|
||||
unsigned new_prev = (src[i] >> comp_shift);
|
||||
dst[i] = src[i];
|
||||
dst[i] <<= bit_shift;
|
||||
|
|
@ -225,7 +225,7 @@ void shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
}
|
||||
if (dst_sz > src_sz) {
|
||||
dst[src_sz] = prev;
|
||||
for (unsigned i = src_sz+1; i < dst_sz; i++)
|
||||
for (unsigned i = src_sz+1; i < dst_sz; ++i)
|
||||
dst[i] = 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -252,7 +252,7 @@ void shr(unsigned sz, unsigned const * src, unsigned k, unsigned * dst) {
|
|||
unsigned i = 0;
|
||||
unsigned j = digit_shift;
|
||||
if (bit_shift != 0) {
|
||||
for (; i < new_sz - 1; i++, j++) {
|
||||
for (; i < new_sz - 1; ++i, ++j) {
|
||||
dst[i] = src[j];
|
||||
dst[i] >>= bit_shift;
|
||||
dst[i] |= (src[j+1] << comp_shift);
|
||||
|
|
@ -261,18 +261,18 @@ void shr(unsigned sz, unsigned const * src, unsigned k, unsigned * dst) {
|
|||
dst[i] >>= bit_shift;
|
||||
}
|
||||
else {
|
||||
for (; i < new_sz; i++, j++) {
|
||||
for (; i < new_sz; ++i, ++j) {
|
||||
dst[i] = src[j];
|
||||
}
|
||||
}
|
||||
for (unsigned i = new_sz; i < sz; i++)
|
||||
for (unsigned i = new_sz; i < sz; ++i)
|
||||
dst[i] = 0;
|
||||
}
|
||||
else {
|
||||
SASSERT(new_sz == sz);
|
||||
SASSERT(bit_shift != 0);
|
||||
unsigned i = 0;
|
||||
for (; i < new_sz - 1; i++) {
|
||||
for (; i < new_sz - 1; ++i) {
|
||||
dst[i] = src[i];
|
||||
dst[i] >>= bit_shift;
|
||||
dst[i] |= (src[i+1] << comp_shift);
|
||||
|
|
@ -298,7 +298,7 @@ void shr(unsigned src_sz, unsigned const * src, unsigned k, unsigned dst_sz, uns
|
|||
unsigned sz = new_sz;
|
||||
if (new_sz > dst_sz)
|
||||
sz = dst_sz;
|
||||
for (; i < sz - 1; i++, j++) {
|
||||
for (; i < sz - 1; ++i, ++j) {
|
||||
dst[i] = src[j];
|
||||
dst[i] >>= bit_shift;
|
||||
dst[i] |= (src[j+1] << comp_shift);
|
||||
|
|
@ -311,7 +311,7 @@ void shr(unsigned src_sz, unsigned const * src, unsigned k, unsigned dst_sz, uns
|
|||
else {
|
||||
if (new_sz > dst_sz)
|
||||
new_sz = dst_sz;
|
||||
for (; i < new_sz; i++, j++) {
|
||||
for (; i < new_sz; ++i, ++j) {
|
||||
dst[i] = src[j];
|
||||
}
|
||||
}
|
||||
|
|
@ -323,7 +323,7 @@ void shr(unsigned src_sz, unsigned const * src, unsigned k, unsigned dst_sz, uns
|
|||
if (new_sz > dst_sz)
|
||||
sz = dst_sz;
|
||||
unsigned i = 0;
|
||||
for (; i < sz - 1; i++) {
|
||||
for (; i < sz - 1; ++i) {
|
||||
dst[i] = src[i];
|
||||
dst[i] >>= bit_shift;
|
||||
dst[i] |= (src[i+1] << comp_shift);
|
||||
|
|
@ -333,7 +333,7 @@ void shr(unsigned src_sz, unsigned const * src, unsigned k, unsigned dst_sz, uns
|
|||
if (new_sz > dst_sz)
|
||||
dst[i] |= (src[i+1] << comp_shift);
|
||||
}
|
||||
for (unsigned i = new_sz; i < dst_sz; i++)
|
||||
for (unsigned i = new_sz; i < dst_sz; ++i)
|
||||
dst[i] = 0;
|
||||
}
|
||||
|
||||
|
|
@ -345,7 +345,7 @@ bool has_one_at_first_k_bits(unsigned sz, unsigned const * data, unsigned k) {
|
|||
unsigned word_sz = k / (8 * sizeof(unsigned));
|
||||
if (word_sz > sz)
|
||||
word_sz = sz;
|
||||
for (unsigned i = 0; i < word_sz; i++) {
|
||||
for (unsigned i = 0; i < word_sz; ++i) {
|
||||
if (data[i] != 0)
|
||||
return true;
|
||||
}
|
||||
|
|
@ -358,7 +358,7 @@ bool has_one_at_first_k_bits(unsigned sz, unsigned const * data, unsigned k) {
|
|||
}
|
||||
|
||||
bool inc(unsigned sz, unsigned * data) {
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
data[i]++;
|
||||
if (data[i] != 0)
|
||||
return true; // no overflow
|
||||
|
|
@ -367,7 +367,7 @@ bool inc(unsigned sz, unsigned * data) {
|
|||
}
|
||||
|
||||
bool dec(unsigned sz, unsigned * data) {
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
data[i]--;
|
||||
if (data[i] != UINT_MAX)
|
||||
return true; // no underflow
|
||||
|
|
@ -389,7 +389,7 @@ bool lt(unsigned sz, unsigned * data1, unsigned * data2) {
|
|||
|
||||
bool add(unsigned sz, unsigned const * a, unsigned const * b, unsigned * c) {
|
||||
unsigned k = 0;
|
||||
for (unsigned j = 0; j < sz; j++) {
|
||||
for (unsigned j = 0; j < sz; ++j) {
|
||||
unsigned r = a[j] + b[j];
|
||||
bool c1 = r < a[j];
|
||||
c[j] = r + k;
|
||||
|
|
|
|||
|
|
@ -102,13 +102,13 @@ void bit_vector::shift_right(unsigned k) {
|
|||
}
|
||||
if (bit_shift > 0) {
|
||||
DEBUG_CODE({
|
||||
for (unsigned i = 0; i < word_shift; i++) {
|
||||
for (unsigned i = 0; i < word_shift; ++i) {
|
||||
SASSERT(m_data[i] == 0);
|
||||
}
|
||||
});
|
||||
unsigned comp_shift = (8 * sizeof(unsigned)) - bit_shift;
|
||||
unsigned prev = 0;
|
||||
for (unsigned i = word_shift; i < new_num_words; i++) {
|
||||
for (unsigned i = word_shift; i < new_num_words; ++i) {
|
||||
unsigned new_prev = (m_data[i] >> comp_shift);
|
||||
m_data[i] <<= bit_shift;
|
||||
m_data[i] |= prev;
|
||||
|
|
@ -124,7 +124,7 @@ bool bit_vector::operator==(bit_vector const & source) const {
|
|||
if (n == 0)
|
||||
return true;
|
||||
unsigned i;
|
||||
for (i = 0; i < n - 1; i++) {
|
||||
for (i = 0; i < n - 1; ++i) {
|
||||
if (m_data[i] != source.m_data[i])
|
||||
return false;
|
||||
}
|
||||
|
|
@ -142,12 +142,12 @@ bit_vector & bit_vector::operator|=(bit_vector const & source) {
|
|||
unsigned bit_rest = source.m_num_bits % 32;
|
||||
if (bit_rest == 0) {
|
||||
unsigned i = 0;
|
||||
for (i = 0; i < n2; i++)
|
||||
for (i = 0; i < n2; ++i)
|
||||
m_data[i] |= source.m_data[i];
|
||||
}
|
||||
else {
|
||||
unsigned i = 0;
|
||||
for (i = 0; i < n2 - 1; i++)
|
||||
for (i = 0; i < n2 - 1; ++i)
|
||||
m_data[i] |= source.m_data[i];
|
||||
unsigned mask = MK_MASK(bit_rest);
|
||||
m_data[i] |= source.m_data[i] & mask;
|
||||
|
|
@ -161,7 +161,7 @@ bit_vector & bit_vector::operator&=(bit_vector const & source) {
|
|||
if (n1 == 0)
|
||||
return *this;
|
||||
if (n2 > n1) {
|
||||
for (unsigned i = 0; i < n1; i++)
|
||||
for (unsigned i = 0; i < n1; ++i)
|
||||
m_data[i] &= source.m_data[i];
|
||||
}
|
||||
else {
|
||||
|
|
@ -169,17 +169,17 @@ bit_vector & bit_vector::operator&=(bit_vector const & source) {
|
|||
unsigned bit_rest = source.m_num_bits % 32;
|
||||
unsigned i = 0;
|
||||
if (bit_rest == 0) {
|
||||
for (i = 0; i < n2; i++)
|
||||
for (i = 0; i < n2; ++i)
|
||||
m_data[i] &= source.m_data[i];
|
||||
}
|
||||
else {
|
||||
for (i = 0; i < n2 - 1; i++)
|
||||
for (i = 0; i < n2 - 1; ++i)
|
||||
m_data[i] &= source.m_data[i];
|
||||
unsigned mask = MK_MASK(bit_rest);
|
||||
m_data[i] &= (source.m_data[i] & mask);
|
||||
|
||||
}
|
||||
for (i = n2; i < n1; i++)
|
||||
for (i = n2; i < n1; ++i)
|
||||
m_data[i] = 0;
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -196,7 +196,7 @@ void bit_vector::display(std::ostream & out) const {
|
|||
out << "0";
|
||||
}
|
||||
#else
|
||||
for (unsigned i = 0; i < m_num_bits; i++) {
|
||||
for (unsigned i = 0; i < m_num_bits; ++i) {
|
||||
if (get(i))
|
||||
out << "1";
|
||||
else
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ public:
|
|||
}
|
||||
|
||||
buffer(unsigned sz, const T & elem) {
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
push_back(elem);
|
||||
}
|
||||
SASSERT(size() == sz);
|
||||
|
|
@ -193,7 +193,7 @@ public:
|
|||
}
|
||||
|
||||
void append(unsigned n, T const * elems) {
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
push_back(elems[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -230,12 +230,12 @@ public:
|
|||
void resize(unsigned nsz, const T & elem=T()) {
|
||||
unsigned sz = size();
|
||||
if (nsz > sz) {
|
||||
for (unsigned i = sz; i < nsz; i++) {
|
||||
for (unsigned i = sz; i < nsz; ++i) {
|
||||
push_back(elem);
|
||||
}
|
||||
}
|
||||
else if (nsz < sz) {
|
||||
for (unsigned i = nsz; i < sz; i++) {
|
||||
for (unsigned i = nsz; i < sz; ++i) {
|
||||
pop_back();
|
||||
}
|
||||
}
|
||||
|
|
@ -245,7 +245,7 @@ public:
|
|||
void shrink(unsigned nsz) {
|
||||
unsigned sz = size();
|
||||
SASSERT(nsz <= sz);
|
||||
for (unsigned i = nsz; i < sz; i++)
|
||||
for (unsigned i = nsz; i < sz; ++i)
|
||||
pop_back();
|
||||
SASSERT(size() == nsz);
|
||||
}
|
||||
|
|
@ -266,7 +266,7 @@ template<typename T, unsigned INITIAL_SIZE=16>
|
|||
class ptr_buffer : public buffer<T *, false, INITIAL_SIZE> {
|
||||
public:
|
||||
void append(unsigned n, T * const * elems) {
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
this->push_back(elems[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ protected:
|
|||
}
|
||||
#if 0
|
||||
TRACE(chashtable,
|
||||
for (unsigned i = 0; i < source_capacity; i++) {
|
||||
for (unsigned i = 0; i < source_capacity; ++i) {
|
||||
tout << i << ":[";
|
||||
if (source[i].m_next == 0)
|
||||
tout << "null";
|
||||
|
|
@ -141,7 +141,7 @@ protected:
|
|||
tout << ", " << source[i].m_data << "]\n";
|
||||
}
|
||||
tout << "\n";
|
||||
for (unsigned i = 0; i < target_capacity; i++) {
|
||||
for (unsigned i = 0; i < target_capacity; ++i) {
|
||||
tout << i << ":[";
|
||||
if (target[i].m_next == 0)
|
||||
tout << "null";
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ void print_map(const T & cont, std::ostream & out) {
|
|||
template<class It, class V>
|
||||
unsigned find_index(const It & begin, const It & end, const V & val) {
|
||||
It it = begin;
|
||||
for (unsigned idx = 0; it != end; it++, idx++) {
|
||||
for (unsigned idx = 0; it != end; ++it, ++idx) {
|
||||
if (*it == val) {
|
||||
return idx;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ public:
|
|||
vs.push_back(to_leaf(d)->m_value);
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < 2; i++) {
|
||||
for (unsigned i = 0; i < 2; ++i) {
|
||||
dependency* child = to_join(d)->m_children[i];
|
||||
if (!child->is_marked()) {
|
||||
todo.push_back(child);
|
||||
|
|
@ -125,7 +125,7 @@ private:
|
|||
m_allocator.deallocate(sizeof(leaf), to_leaf(d));
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < 2; i++) {
|
||||
for (unsigned i = 0; i < 2; ++i) {
|
||||
dependency * c = to_join(d)->m_children[i];
|
||||
SASSERT(c->m_ref_count > 0);
|
||||
c->m_ref_count--;
|
||||
|
|
@ -208,7 +208,7 @@ public:
|
|||
}
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < 2; i++) {
|
||||
for (unsigned i = 0; i < 2; ++i) {
|
||||
dependency * child = to_join(d)->m_children[i];
|
||||
if (!child->is_marked()) {
|
||||
m_todo.push_back(child);
|
||||
|
|
|
|||
|
|
@ -100,21 +100,21 @@ fixed_bit_vector_manager::fill1(fixed_bit_vector& bv) const {
|
|||
|
||||
fixed_bit_vector&
|
||||
fixed_bit_vector_manager::set_and(fixed_bit_vector& dst, fixed_bit_vector const& src) const {
|
||||
for (unsigned i = 0; i < m_num_words; i++)
|
||||
for (unsigned i = 0; i < m_num_words; ++i)
|
||||
dst.m_data[i] &= src.m_data[i];
|
||||
return dst;
|
||||
}
|
||||
|
||||
fixed_bit_vector&
|
||||
fixed_bit_vector_manager::set_or(fixed_bit_vector& dst, fixed_bit_vector const& src) const {
|
||||
for (unsigned i = 0; i < m_num_words; i++)
|
||||
for (unsigned i = 0; i < m_num_words; ++i)
|
||||
dst.m_data[i] |= src.m_data[i];
|
||||
return dst;
|
||||
}
|
||||
|
||||
fixed_bit_vector&
|
||||
fixed_bit_vector_manager::set_neg(fixed_bit_vector& dst) const {
|
||||
for (unsigned i = 0; i < m_num_words; i++)
|
||||
for (unsigned i = 0; i < m_num_words; ++i)
|
||||
dst.m_data[i] = ~dst.m_data[i];
|
||||
return dst;
|
||||
}
|
||||
|
|
@ -130,7 +130,7 @@ bool fixed_bit_vector_manager::equals(fixed_bit_vector const& a, fixed_bit_vecto
|
|||
unsigned n = num_words();
|
||||
if (n == 0)
|
||||
return true;
|
||||
for (unsigned i = 0; i < n - 1; i++) {
|
||||
for (unsigned i = 0; i < n - 1; ++i) {
|
||||
if (a.m_data[i] != b.m_data[i])
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -236,13 +236,13 @@ public:
|
|||
name++;
|
||||
std::string tmp = name;
|
||||
unsigned n = static_cast<unsigned>(tmp.size());
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
if (tmp[i] >= 'A' && tmp[i] <= 'Z')
|
||||
tmp[i] = tmp[i] - 'A' + 'a';
|
||||
else if (tmp[i] == '-')
|
||||
tmp[i] = '_';
|
||||
}
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
if (tmp[i] == '.') {
|
||||
param_name = tmp.c_str() + i + 1;
|
||||
tmp.resize(i);
|
||||
|
|
|
|||
|
|
@ -443,7 +443,7 @@ std::ostream& mpbq_manager::display_decimal(std::ostream & out, mpbq const & a,
|
|||
SASSERT(!m_manager.is_zero(n1));
|
||||
out << m_manager.to_string(v1);
|
||||
out << ".";
|
||||
for (unsigned i = 0; i < prec; i++) {
|
||||
for (unsigned i = 0; i < prec; ++i) {
|
||||
m_manager.mul(n1, ten, n1);
|
||||
m_manager.div(n1, two_k, v1);
|
||||
m_manager.rem(n1, two_k, n1);
|
||||
|
|
@ -487,7 +487,7 @@ std::ostream& mpbq_manager::display_decimal(std::ostream & out, mpbq const & a,
|
|||
if (m_manager.is_zero(n1) && m_manager.is_zero(n2))
|
||||
goto end; // number is an integer
|
||||
out << ".";
|
||||
for (unsigned i = 0; i < prec; i++) {
|
||||
for (unsigned i = 0; i < prec; ++i) {
|
||||
m_manager.mul(n1, ten, n1);
|
||||
m_manager.mul(n2, ten, n2);
|
||||
m_manager.div(n1, two_k1, v1);
|
||||
|
|
|
|||
|
|
@ -1197,7 +1197,7 @@ void mpf_manager::to_sbv_mpq(mpf_rounding_mode rm, const mpf & x, scoped_mpq & o
|
|||
mpf_exp_t e = (mpf_exp_t)t.exponent() - t.sbits() + 1;
|
||||
if (e < 0) {
|
||||
bool last = m_mpz_manager.is_odd(z), round = false, sticky = false;
|
||||
for (; e != 0; e++) {
|
||||
for (; e != 0; ++e) {
|
||||
m_mpz_manager.machine_div2k(z, 1);
|
||||
sticky |= round;
|
||||
round = last;
|
||||
|
|
@ -1662,7 +1662,7 @@ std::string mpf_manager::to_string_binary(mpf const & x, unsigned upper_extra, u
|
|||
}
|
||||
|
||||
std::string tmp_str = "";
|
||||
for (unsigned i = 0; i < x.ebits; i++) {
|
||||
for (unsigned i = 0; i < x.ebits; ++i) {
|
||||
tmp_str += m_mpz_manager.is_odd(tmp) ? "1" : "0";
|
||||
tmp /= 2;
|
||||
}
|
||||
|
|
@ -1672,7 +1672,7 @@ std::string mpf_manager::to_string_binary(mpf const & x, unsigned upper_extra, u
|
|||
tmp_str = "";
|
||||
m_mpz_manager.set(tmp, sig(x));
|
||||
unsigned num_bits = upper_extra + x.sbits + lower_extra;
|
||||
for (unsigned i = 0; i < num_bits || !tmp.is_zero(); i++) {
|
||||
for (unsigned i = 0; i < num_bits || !tmp.is_zero(); ++i) {
|
||||
tmp_str += m_mpz_manager.is_odd(tmp) ? "1" : "0";
|
||||
tmp /= 2;
|
||||
if (i == lower_extra - 1)
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ mpff_manager::mpff_manager(unsigned prec, unsigned initial_capacity) {
|
|||
m_capacity = initial_capacity;
|
||||
m_to_plus_inf = false;
|
||||
m_significands.resize(initial_capacity * prec, 0);
|
||||
for (unsigned i = 0; i < MPFF_NUM_BUFFERS; i++)
|
||||
for (unsigned i = 0; i < MPFF_NUM_BUFFERS; ++i)
|
||||
m_buffers[i].resize(2 * prec, 0);
|
||||
// Reserve space for zero
|
||||
VERIFY(m_id_gen.mk() == 0);
|
||||
|
|
@ -63,7 +63,7 @@ void mpff_manager::allocate(mpff & n) {
|
|||
n.m_sig_idx = sig_idx;
|
||||
DEBUG_CODE({
|
||||
unsigned * s = sig(n);
|
||||
for (unsigned i = 0; i < m_precision; i++) {
|
||||
for (unsigned i = 0; i < m_precision; ++i) {
|
||||
SASSERT(s[i] == 0);
|
||||
}
|
||||
});
|
||||
|
|
@ -73,7 +73,7 @@ void mpff_manager::to_buffer(unsigned idx, mpff const & n) const {
|
|||
SASSERT(idx < MPFF_NUM_BUFFERS);
|
||||
svector<unsigned> & b = const_cast<mpff_manager*>(this)->m_buffers[idx];
|
||||
unsigned * s = sig(n);
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
b[i] = s[i];
|
||||
}
|
||||
|
||||
|
|
@ -82,7 +82,7 @@ void mpff_manager::to_buffer_ext(unsigned idx, mpff const & n) const {
|
|||
svector<unsigned> & b = const_cast<mpff_manager*>(this)->m_buffers[idx];
|
||||
unsigned * s = sig(n);
|
||||
unsigned j = m_precision;
|
||||
for (unsigned i = 0; i < m_precision; i++, j++) {
|
||||
for (unsigned i = 0; i < m_precision; ++i, ++j) {
|
||||
b[i] = s[i];
|
||||
b[j] = 0;
|
||||
}
|
||||
|
|
@ -93,7 +93,7 @@ void mpff_manager::to_buffer_shifting(unsigned idx, mpff const & n) const {
|
|||
svector<unsigned> & b = const_cast<mpff_manager*>(this)->m_buffers[idx];
|
||||
unsigned * s = sig(n);
|
||||
unsigned j = m_precision;
|
||||
for (unsigned i = 0; i < m_precision; i++, j++) {
|
||||
for (unsigned i = 0; i < m_precision; ++i, ++j) {
|
||||
b[i] = 0;
|
||||
b[j] = s[i];
|
||||
}
|
||||
|
|
@ -104,7 +104,7 @@ void mpff_manager::del(mpff & n) {
|
|||
if (sig_idx != 0) {
|
||||
m_id_gen.recycle(sig_idx);
|
||||
unsigned * s = sig(n);
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
s[i] = 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -192,7 +192,7 @@ bool mpff_manager::is_abs_one(mpff const & n) const {
|
|||
unsigned * s = sig(n);
|
||||
if (s[m_precision - 1] != 0x80000000u)
|
||||
return false;
|
||||
for (unsigned i = 0; i < m_precision - 1; i++)
|
||||
for (unsigned i = 0; i < m_precision - 1; ++i)
|
||||
if (s[i] != 0)
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -209,7 +209,7 @@ bool mpff_manager::is_two(mpff const & n) const {
|
|||
unsigned * s = sig(n);
|
||||
if (s[m_precision - 1] != 0x80000000u)
|
||||
return false;
|
||||
for (unsigned i = 0; i < m_precision - 1; i++)
|
||||
for (unsigned i = 0; i < m_precision - 1; ++i)
|
||||
if (s[i] != 0)
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -243,7 +243,7 @@ void mpff_manager::set(mpff & n, unsigned v) {
|
|||
v <<= num_leading_zeros;
|
||||
unsigned * s = sig(n);
|
||||
s[m_precision - 1] = v;
|
||||
for (unsigned i = 0; i < m_precision - 1; i++)
|
||||
for (unsigned i = 0; i < m_precision - 1; ++i)
|
||||
s[i] = 0;
|
||||
}
|
||||
SASSERT(check(n));
|
||||
|
|
@ -284,7 +284,7 @@ void mpff_manager::set(mpff & n, uint64_t v) {
|
|||
unsigned * s = sig(n);
|
||||
s[m_precision-1] = _v[1];
|
||||
s[m_precision-2] = _v[0];
|
||||
for (unsigned i = 0; i < m_precision - 2; i++)
|
||||
for (unsigned i = 0; i < m_precision - 2; ++i)
|
||||
s[i] = 0;
|
||||
}
|
||||
SASSERT(check(n));
|
||||
|
|
@ -319,7 +319,7 @@ void mpff_manager::set(mpff & n, mpff const & v) {
|
|||
n.m_exponent = v.m_exponent;
|
||||
unsigned * s1 = sig(n);
|
||||
unsigned * s2 = sig(v);
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
s1[i] = s2[i];
|
||||
SASSERT(check(n));
|
||||
}
|
||||
|
|
@ -342,7 +342,7 @@ void mpff_manager::set_core(mpff & n, mpz_manager<SYNCH> & m, mpz const & v) {
|
|||
while (w.size() < m_precision) {
|
||||
w.push_back(0);
|
||||
}
|
||||
TRACE(mpff, tout << "w words: "; for (unsigned i = 0; i < w.size(); i++) tout << w[i] << " "; tout << "\n";);
|
||||
TRACE(mpff, tout << "w words: "; for (unsigned i = 0; i < w.size(); ++i) tout << w[i] << " "; tout << "\n";);
|
||||
unsigned w_sz = w.size();
|
||||
SASSERT(w_sz >= m_precision);
|
||||
unsigned num_leading_zeros = nlz(w_sz, w.data());
|
||||
|
|
@ -415,7 +415,7 @@ bool mpff_manager::eq(mpff const & a, mpff const & b) const {
|
|||
return false;
|
||||
unsigned * s1 = sig(a);
|
||||
unsigned * s2 = sig(b);
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
if (s1[i] != s2[i])
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -500,7 +500,7 @@ void mpff_manager::inc_significand(mpff & a) {
|
|||
void mpff_manager::dec_significand(mpff & a) {
|
||||
SASSERT(!is_minus_epsilon(a) && !is_zero(a) && !is_plus_epsilon(a));
|
||||
unsigned * s = sig(a);
|
||||
for (unsigned i = 0; i < m_precision - 1; i++) {
|
||||
for (unsigned i = 0; i < m_precision - 1; ++i) {
|
||||
s[i]--;
|
||||
if (s[i] != UINT_MAX)
|
||||
return;
|
||||
|
|
@ -530,14 +530,14 @@ void mpff_manager::set_min_significand(mpff & a) {
|
|||
// we have that 0x8000..00 is the minimal significand
|
||||
unsigned * s = sig(a);
|
||||
s[m_precision - 1] = MIN_MSW;
|
||||
for (unsigned i = 0; i < m_precision - 1; i++)
|
||||
for (unsigned i = 0; i < m_precision - 1; ++i)
|
||||
s[i] = 0;
|
||||
}
|
||||
|
||||
void mpff_manager::set_max_significand(mpff & a) {
|
||||
SASSERT(!is_zero(a));
|
||||
unsigned * s = sig(a);
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
s[i] = UINT_MAX;
|
||||
}
|
||||
|
||||
|
|
@ -713,7 +713,7 @@ void mpff_manager::add_sub(bool is_sub, mpff const & a, mpff const & b, mpff & c
|
|||
if (num_leading_zeros == sizeof(unsigned) * 8) {
|
||||
// no shift is needed
|
||||
c.m_exponent = exp_a;
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
sig_c[i] = sig_r[i];
|
||||
}
|
||||
else if (num_leading_zeros == sizeof(unsigned) * 8 - 1) {
|
||||
|
|
@ -1036,7 +1036,7 @@ void mpff_manager::power(mpff const & a, unsigned p, mpff & b) {
|
|||
throw overflow_exception();
|
||||
unsigned * r = sig(b);
|
||||
r[m_precision - 1] = 0x80000000u;
|
||||
for (unsigned i = 0; i < m_precision - 1; i++)
|
||||
for (unsigned i = 0; i < m_precision - 1; ++i)
|
||||
r[i] = 0;
|
||||
b.m_exponent = static_cast<int>(exp);
|
||||
}
|
||||
|
|
@ -1247,10 +1247,10 @@ void mpff_manager::display_decimal(std::ostream & out, mpff const & n, unsigned
|
|||
sbuffer<unsigned, 1024> buffer;
|
||||
unsigned num_extra_words = 1 + static_cast<unsigned>(exp/word_sz);
|
||||
unsigned shift = word_sz - exp%word_sz;
|
||||
for (unsigned i = 0; i < num_extra_words; i++)
|
||||
for (unsigned i = 0; i < num_extra_words; ++i)
|
||||
buffer.push_back(0);
|
||||
unsigned * s = sig(n);
|
||||
for (unsigned i = 0; i < m_precision; i++)
|
||||
for (unsigned i = 0; i < m_precision; ++i)
|
||||
buffer.push_back(s[i]);
|
||||
shr(buffer.size(), buffer.data(), shift, buffer.size(), buffer.data());
|
||||
sbuffer<char, 1024> str_buffer(11*buffer.size(), 0);
|
||||
|
|
@ -1264,12 +1264,12 @@ void mpff_manager::display_decimal(std::ostream & out, mpff const & n, unsigned
|
|||
unsigned num_extra_words = m_precision < num_words ? num_words - m_precision : 0;
|
||||
num_extra_words++;
|
||||
unsigned * s = sig(n);
|
||||
for (unsigned i = 0; i < m_precision; i++) {
|
||||
for (unsigned i = 0; i < m_precision; ++i) {
|
||||
buffer1.push_back(s[i]);
|
||||
buffer2.push_back(0);
|
||||
buffer3.push_back(0);
|
||||
}
|
||||
for (unsigned i = 0; i < num_extra_words; i++) {
|
||||
for (unsigned i = 0; i < num_extra_words; ++i) {
|
||||
buffer1.push_back(0);
|
||||
buffer2.push_back(0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ void mpfx_manager::del(mpfx & n) {
|
|||
if (sig_idx != 0) {
|
||||
m_id_gen.recycle(sig_idx);
|
||||
unsigned * w = words(n);
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
w[i] = 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -90,7 +90,7 @@ void mpfx_manager::reset(mpfx & n) {
|
|||
|
||||
bool mpfx_manager::is_int(mpfx const & n) const {
|
||||
unsigned * w = words(n);
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++)
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i)
|
||||
if (w[i] != 0)
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -109,7 +109,7 @@ bool mpfx_manager::is_int64(mpfx const & a) const {
|
|||
unsigned * w = words(a);
|
||||
w += m_frac_part_sz;
|
||||
if (w[1] < 0x80000000u || (w[1] == 0x80000000u && is_neg(a))) {
|
||||
for (unsigned i = 2; i < m_int_part_sz; i++)
|
||||
for (unsigned i = 2; i < m_int_part_sz; ++i)
|
||||
if (w[i] != 0)
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -125,7 +125,7 @@ bool mpfx_manager::is_uint64(mpfx const & a) const {
|
|||
if (is_zero(a) || m_int_part_sz <= 2)
|
||||
return true;
|
||||
unsigned * w = words(a);
|
||||
for (unsigned i = m_frac_part_sz + 2; i < m_total_sz; i++)
|
||||
for (unsigned i = m_frac_part_sz + 2; i < m_total_sz; ++i)
|
||||
if (w[i] != 0)
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -156,7 +156,7 @@ void mpfx_manager::set(mpfx & n, unsigned v) {
|
|||
allocate_if_needed(n);
|
||||
n.m_sign = 0;
|
||||
unsigned * w = words(n);
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
w[i] = 0;
|
||||
w[m_frac_part_sz] = v;
|
||||
}
|
||||
|
|
@ -204,7 +204,7 @@ void mpfx_manager::set(mpfx & n, uint64_t v) {
|
|||
uint64_t * _vp = &v;
|
||||
unsigned * _v = nullptr;
|
||||
memcpy(&_v, &_vp, sizeof(unsigned*));
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
w[i] = 0;
|
||||
w[m_frac_part_sz] = _v[0];
|
||||
if (m_int_part_sz == 1) {
|
||||
|
|
@ -244,7 +244,7 @@ void mpfx_manager::set(mpfx & n, mpfx const & v) {
|
|||
n.m_sign = v.m_sign;
|
||||
unsigned * w1 = words(n);
|
||||
unsigned * w2 = words(v);
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
w1[i] = w2[i];
|
||||
SASSERT(check(n));
|
||||
}
|
||||
|
|
@ -262,7 +262,7 @@ void mpfx_manager::set_core(mpfx & n, mpz_manager<SYNCH> & m, mpz const & v) {
|
|||
if (sz > m_int_part_sz)
|
||||
throw overflow_exception();
|
||||
unsigned * w = words(n);
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++)
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i)
|
||||
w[i] = 0;
|
||||
::copy(sz, m_tmp_digits.data(), m_int_part_sz, w + m_frac_part_sz);
|
||||
}
|
||||
|
|
@ -327,7 +327,7 @@ bool mpfx_manager::eq(mpfx const & a, mpfx const & b) const {
|
|||
return false;
|
||||
unsigned * w1 = words(a);
|
||||
unsigned * w2 = words(b);
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
if (w1[i] != w2[i])
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -442,7 +442,7 @@ void mpfx_manager::mul(mpfx const & a, mpfx const & b, mpfx & c) {
|
|||
throw overflow_exception();
|
||||
// copy result to c
|
||||
unsigned * w_c = words(c);
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
w_c[i] = _r[i];
|
||||
}
|
||||
STRACE(mpfx_trace, display(tout, c); tout << "\n";);
|
||||
|
|
@ -463,9 +463,9 @@ void mpfx_manager::div(mpfx const & a, mpfx const & b, mpfx & c) {
|
|||
unsigned * w_a_shft = m_buffer0.data();
|
||||
unsigned a_shft_sz = sz(w_a) + m_frac_part_sz;
|
||||
// copy a to buffer 0, and shift by m_frac_part_sz
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++)
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i)
|
||||
w_a_shft[i] = 0;
|
||||
for (unsigned i = 0; i < m_total_sz; i++)
|
||||
for (unsigned i = 0; i < m_total_sz; ++i)
|
||||
w_a_shft[i+m_frac_part_sz] = w_a[i];
|
||||
unsigned * w_b = words(b);
|
||||
unsigned b_sz = sz(w_b);
|
||||
|
|
@ -484,7 +484,7 @@ void mpfx_manager::div(mpfx const & a, mpfx const & b, mpfx & c) {
|
|||
w_b, b_sz,
|
||||
w_q,
|
||||
w_r);
|
||||
for (unsigned i = m_total_sz; i < q_sz; i++)
|
||||
for (unsigned i = m_total_sz; i < q_sz; ++i)
|
||||
if (w_q[i] != 0)
|
||||
throw overflow_exception();
|
||||
if (((c.m_sign == 1) != m_to_plus_inf) && !::is_zero(r_sz, w_r)) {
|
||||
|
|
@ -496,16 +496,16 @@ void mpfx_manager::div(mpfx const & a, mpfx const & b, mpfx & c) {
|
|||
bool zero_q = true;
|
||||
if (m_total_sz >= q_sz) {
|
||||
unsigned i;
|
||||
for (i = 0; i < q_sz; i++) {
|
||||
for (i = 0; i < q_sz; ++i) {
|
||||
if (w_q[i] != 0)
|
||||
zero_q = false;
|
||||
w_c[i] = w_q[i];
|
||||
}
|
||||
for (; i < m_total_sz; i++)
|
||||
for (; i < m_total_sz; ++i)
|
||||
w_c[i] = 0;
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < m_total_sz; i++) {
|
||||
for (unsigned i = 0; i < m_total_sz; ++i) {
|
||||
if (w_q[i] != 0)
|
||||
zero_q = false;
|
||||
w_c[i] = w_q[i];
|
||||
|
|
@ -544,7 +544,7 @@ void mpfx_manager::div2k(mpfx & a, unsigned k) {
|
|||
void mpfx_manager::set_epsilon(mpfx & n) {
|
||||
unsigned * w = words(n);
|
||||
w[0] = 1;
|
||||
for (unsigned i = 1; i < m_total_sz; i++)
|
||||
for (unsigned i = 1; i < m_total_sz; ++i)
|
||||
w[i] = 0;
|
||||
}
|
||||
|
||||
|
|
@ -565,7 +565,7 @@ void mpfx_manager::floor(mpfx & n) {
|
|||
unsigned * w = words(n);
|
||||
if (is_neg(n)) {
|
||||
bool is_int = true;
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++) {
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i) {
|
||||
if (w[i] != 0) {
|
||||
is_int = false;
|
||||
w[i] = 0;
|
||||
|
|
@ -575,7 +575,7 @@ void mpfx_manager::floor(mpfx & n) {
|
|||
throw overflow_exception();
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++)
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i)
|
||||
w[i] = 0;
|
||||
}
|
||||
if (::is_zero(m_int_part_sz, w + m_frac_part_sz))
|
||||
|
|
@ -589,7 +589,7 @@ void mpfx_manager::ceil(mpfx & n) {
|
|||
unsigned * w = words(n);
|
||||
if (is_pos(n)) {
|
||||
bool is_int = true;
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++) {
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i) {
|
||||
if (w[i] != 0) {
|
||||
is_int = false;
|
||||
w[i] = 0;
|
||||
|
|
@ -599,7 +599,7 @@ void mpfx_manager::ceil(mpfx & n) {
|
|||
throw overflow_exception();
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++)
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i)
|
||||
w[i] = 0;
|
||||
}
|
||||
if (::is_zero(m_int_part_sz, w + m_frac_part_sz))
|
||||
|
|
@ -812,7 +812,7 @@ void mpfx_manager::display_smt2(std::ostream & out, mpfx const & n) const {
|
|||
if (!is_int(n)) {
|
||||
out << " ";
|
||||
unsigned * w = m_buffer0.data();
|
||||
for (unsigned i = 0; i < m_frac_part_sz; i++)
|
||||
for (unsigned i = 0; i < m_frac_part_sz; ++i)
|
||||
w[i] = 0;
|
||||
w[m_frac_part_sz] = 1;
|
||||
sbuffer<char, 1024> str_buffer2(11*(m_frac_part_sz+1), 0);
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ bool mpn_manager::add(mpn_digit const * a, unsigned lnga,
|
|||
mpn_digit k = 0;
|
||||
mpn_digit r;
|
||||
bool c1, c2;
|
||||
for (unsigned j = 0; j < len; j++) {
|
||||
for (unsigned j = 0; j < len; ++j) {
|
||||
mpn_digit u_j = (j < lnga) ? a[j] : 0;
|
||||
mpn_digit v_j = (j < lngb) ? b[j] : 0;
|
||||
r = u_j + v_j; c1 = r < u_j;
|
||||
|
|
@ -81,7 +81,7 @@ bool mpn_manager::sub(mpn_digit const * a, unsigned lnga,
|
|||
mpn_digit & k = *pborrow; k = 0;
|
||||
mpn_digit r;
|
||||
bool c1, c2;
|
||||
for (unsigned j = 0; j < len; j++) {
|
||||
for (unsigned j = 0; j < len; ++j) {
|
||||
mpn_digit u_j = (j < lnga) ? a[j] : 0;
|
||||
mpn_digit v_j = (j < lngb) ? b[j] : 0;
|
||||
r = u_j - v_j; c1 = r > u_j;
|
||||
|
|
@ -104,17 +104,17 @@ bool mpn_manager::mul(mpn_digit const * a, unsigned lnga,
|
|||
#define DIGIT_BITS (sizeof(mpn_digit)*8)
|
||||
#define HALF_BITS (sizeof(mpn_digit)*4)
|
||||
|
||||
for (unsigned i = 0; i < lnga; i++)
|
||||
for (unsigned i = 0; i < lnga; ++i)
|
||||
c[i] = 0;
|
||||
|
||||
for (unsigned j = 0; j < lngb; j++) {
|
||||
for (unsigned j = 0; j < lngb; ++j) {
|
||||
mpn_digit v_j = b[j];
|
||||
if (v_j == 0) { // This branch may be omitted according to Knuth.
|
||||
c[j+lnga] = 0;
|
||||
}
|
||||
else {
|
||||
k = 0;
|
||||
for (i = 0; i < lnga; i++) {
|
||||
for (i = 0; i < lnga; ++i) {
|
||||
mpn_digit u_i = a[i];
|
||||
mpn_double_digit t;
|
||||
t = ((mpn_double_digit)u_i * (mpn_double_digit)v_j) +
|
||||
|
|
@ -145,9 +145,9 @@ bool mpn_manager::div(mpn_digit const * numer, unsigned lnum,
|
|||
bool res = false;
|
||||
|
||||
if (lnum < lden) {
|
||||
for (unsigned i = 0; i < (lnum-lden+1); i++)
|
||||
for (unsigned i = 0; i < (lnum-lden+1); ++i)
|
||||
quot[i] = 0;
|
||||
for (unsigned i = 0; i < lden; i++)
|
||||
for (unsigned i = 0; i < lden; ++i)
|
||||
rem[i] = (i < lnum) ? numer[i] : 0;
|
||||
return false;
|
||||
}
|
||||
|
|
@ -160,7 +160,7 @@ bool mpn_manager::div(mpn_digit const * numer, unsigned lnum,
|
|||
}
|
||||
else if (lnum < lden || (lnum == lden && numer[lnum-1] < denom[lden-1])) {
|
||||
*quot = 0;
|
||||
for (unsigned i = 0; i < lden; i++)
|
||||
for (unsigned i = 0; i < lden; ++i)
|
||||
rem[i] = (i < lnum) ? numer[i] : 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -186,7 +186,7 @@ bool mpn_manager::div(mpn_digit const * numer, unsigned lnum,
|
|||
unsigned real_size;
|
||||
add(temp.data(), lnum, rem, lden, temp.data(), lnum+1, &real_size);
|
||||
bool ok = true;
|
||||
for (unsigned i = 0; i < lnum && ok; i++)
|
||||
for (unsigned i = 0; i < lnum && ok; ++i)
|
||||
if (temp[i] != numer[i]) ok = false;
|
||||
if (temp[lnum] != 0) ok = false;
|
||||
CTRACE(mpn_dbg, !ok, tout << "DIV BUG: quot * denom + rem = "; display_raw(tout, temp.data(), lnum+1); tout << std::endl; );
|
||||
|
|
@ -210,9 +210,9 @@ unsigned mpn_manager::div_normalize(mpn_digit const * numer, unsigned lnum,
|
|||
|
||||
if (d == 0) {
|
||||
n_numer[lnum] = 0;
|
||||
for (unsigned i = 0; i < lnum; i++)
|
||||
for (unsigned i = 0; i < lnum; ++i)
|
||||
n_numer[i] = numer[i];
|
||||
for (unsigned i = 0; i < lden; i++)
|
||||
for (unsigned i = 0; i < lden; ++i)
|
||||
n_denom[i] = denom[i];
|
||||
}
|
||||
else if (lnum != 0) {
|
||||
|
|
@ -238,11 +238,11 @@ unsigned mpn_manager::div_normalize(mpn_digit const * numer, unsigned lnum,
|
|||
void mpn_manager::div_unnormalize(mpn_sbuffer & numer, mpn_sbuffer & denom,
|
||||
unsigned d, mpn_digit * rem) const {
|
||||
if (d == 0) {
|
||||
for (unsigned i = 0; i < denom.size(); i++)
|
||||
for (unsigned i = 0; i < denom.size(); ++i)
|
||||
rem[i] = numer[i];
|
||||
}
|
||||
else {
|
||||
for (unsigned i = 0; i < denom.size()-1; i++)
|
||||
for (unsigned i = 0; i < denom.size()-1; ++i)
|
||||
rem[i] = numer[i] >> d | (LAST_BITS(d, numer[i+1]) << (DIGIT_BITS-d));
|
||||
rem[denom.size()-1] = numer[denom.size()-1] >> d;
|
||||
}
|
||||
|
|
@ -320,7 +320,7 @@ bool mpn_manager::div_n(mpn_sbuffer & numer, mpn_sbuffer const & denom,
|
|||
ab.resize(n+2);
|
||||
unsigned real_size;
|
||||
add(denom.data(), n, &numer[j], n+1, ab.data(), n+2, &real_size);
|
||||
for (unsigned i = 0; i < n+1; i++)
|
||||
for (unsigned i = 0; i < n+1; ++i)
|
||||
numer[j+i] = ab[i];
|
||||
}
|
||||
TRACE(mpn_div, tout << "q_hat=" << q_hat << " r_hat=" << r_hat;
|
||||
|
|
@ -346,7 +346,7 @@ char * mpn_manager::to_string(mpn_digit const * a, unsigned lng, char * buf, uns
|
|||
}
|
||||
else {
|
||||
mpn_sbuffer temp(lng, 0), t_numer(lng+1, 0), t_denom(1, 0);
|
||||
for (unsigned i = 0; i < lng; i++)
|
||||
for (unsigned i = 0; i < lng; ++i)
|
||||
temp[i] = a[i];
|
||||
|
||||
unsigned j = 0;
|
||||
|
|
@ -364,7 +364,7 @@ char * mpn_manager::to_string(mpn_digit const * a, unsigned lng, char * buf, uns
|
|||
|
||||
j--;
|
||||
unsigned mid = (j/2) + ((j % 2) ? 1 : 0);
|
||||
for (unsigned i = 0; i < mid; i++)
|
||||
for (unsigned i = 0; i < mid; ++i)
|
||||
std::swap(buf[i], buf[j-i]);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ void mpq_manager<SYNCH>::gcd(unsigned sz, mpq const * as, mpq & g) {
|
|||
break;
|
||||
}
|
||||
gcd(as[0], as[1], g);
|
||||
for (unsigned i = 2; i < sz; i++) {
|
||||
for (unsigned i = 2; i < sz; ++i) {
|
||||
if (is_one(g))
|
||||
return;
|
||||
gcd(g, as[i], g);
|
||||
|
|
@ -164,7 +164,7 @@ void mpq_manager<SYNCH>::display_decimal(std::ostream & out, mpq const & a, unsi
|
|||
if (is_zero(n1))
|
||||
goto end; // number is an integer
|
||||
out << ".";
|
||||
for (unsigned i = 0; i < prec; i++) {
|
||||
for (unsigned i = 0; i < prec; ++i) {
|
||||
mul(n1, ten, n1);
|
||||
div(n1, d1, v1);
|
||||
SASSERT(lt(v1, ten));
|
||||
|
|
|
|||
|
|
@ -1187,20 +1187,20 @@ void mpz_manager<SYNCH>::gcd(unsigned sz, mpz const * as, mpz & g) {
|
|||
break;
|
||||
}
|
||||
unsigned i;
|
||||
for (i = 0; i < sz; i++) {
|
||||
for (i = 0; i < sz; ++i) {
|
||||
if (!is_small(as[i]))
|
||||
break;
|
||||
}
|
||||
if (i != sz) {
|
||||
// array has big numbers
|
||||
sbuffer<unsigned, 1024> p;
|
||||
for (i = 0; i < sz; i++)
|
||||
for (i = 0; i < sz; ++i)
|
||||
p.push_back(i);
|
||||
sz_lt lt(*this, as);
|
||||
std::sort(p.begin(), p.end(), lt);
|
||||
TRACE(mpz_gcd, for (unsigned i = 0; i < sz; i++) tout << p[i] << ":" << size_info(as[p[i]]) << " "; tout << "\n";);
|
||||
TRACE(mpz_gcd, for (unsigned i = 0; i < sz; ++i) tout << p[i] << ":" << size_info(as[p[i]]) << " "; tout << "\n";);
|
||||
gcd(as[p[0]], as[p[1]], g);
|
||||
for (i = 2; i < sz; i++) {
|
||||
for (i = 2; i < sz; ++i) {
|
||||
if (is_one(g))
|
||||
return;
|
||||
gcd(g, as[p[i]], g);
|
||||
|
|
@ -1209,7 +1209,7 @@ void mpz_manager<SYNCH>::gcd(unsigned sz, mpz const * as, mpz & g) {
|
|||
}
|
||||
else {
|
||||
gcd(as[0], as[1], g);
|
||||
for (unsigned i = 2; i < sz; i++) {
|
||||
for (unsigned i = 2; i < sz; ++i) {
|
||||
if (is_one(g))
|
||||
return;
|
||||
gcd(g, as[i], g);
|
||||
|
|
@ -1229,7 +1229,7 @@ void mpz_manager<SYNCH>::gcd(unsigned sz, mpz const * as, mpz & g) {
|
|||
break;
|
||||
}
|
||||
gcd(as[0], as[1], g);
|
||||
for (unsigned i = 2; i < sz; i++) {
|
||||
for (unsigned i = 2; i < sz; ++i) {
|
||||
if (is_one(g))
|
||||
return;
|
||||
gcd(g, as[i], g);
|
||||
|
|
@ -1687,7 +1687,7 @@ double mpz_manager<SYNCH>::get_double(mpz const & a) const {
|
|||
double r = 0.0;
|
||||
double d = 1.0;
|
||||
unsigned sz = size(a);
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
r += d * static_cast<double>(digits(a)[i]);
|
||||
if (sizeof(digit_t) == sizeof(uint64_t))
|
||||
d *= (1.0 + static_cast<double>(UINT64_MAX)); // 64-bit version, multiply by 2^64
|
||||
|
|
@ -1891,7 +1891,7 @@ void mpz_manager<SYNCH>::power(mpz const & a, unsigned p, mpz & b) {
|
|||
allocate_if_needed(b, sz);
|
||||
SASSERT(b.m_ptr->m_capacity >= sz);
|
||||
b.m_ptr->m_size = sz;
|
||||
for (unsigned i = 0; i < sz - 1; i++)
|
||||
for (unsigned i = 0; i < sz - 1; ++i)
|
||||
b.m_ptr->m_digits[i] = 0;
|
||||
b.m_ptr->m_digits[sz-1] = 1 << shift;
|
||||
b.m_val = 1;
|
||||
|
|
@ -1947,7 +1947,7 @@ bool mpz_manager<SYNCH>::is_power_of_two(mpz const & a, unsigned & shift) {
|
|||
mpz_cell * c = a.m_ptr;
|
||||
unsigned sz = c->m_size;
|
||||
digit_t * ds = c->m_digits;
|
||||
for (unsigned i = 0; i < sz - 1; i++) {
|
||||
for (unsigned i = 0; i < sz - 1; ++i) {
|
||||
if (ds[i] != 0)
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1986,7 +1986,7 @@ void mpz_manager<SYNCH>::ensure_capacity(mpz & a, unsigned capacity) {
|
|||
SASSERT(a.m_ptr->m_capacity >= capacity);
|
||||
if (val == INT_MIN) {
|
||||
unsigned intmin_sz = m_int_min.m_ptr->m_size;
|
||||
for (unsigned i = 0; i < intmin_sz; i++)
|
||||
for (unsigned i = 0; i < intmin_sz; ++i)
|
||||
a.m_ptr->m_digits[i] = m_int_min.m_ptr->m_digits[i];
|
||||
a.m_val = -1;
|
||||
a.m_ptr->m_size = m_int_min.m_ptr->m_size;
|
||||
|
|
@ -2007,7 +2007,7 @@ void mpz_manager<SYNCH>::ensure_capacity(mpz & a, unsigned capacity) {
|
|||
SASSERT(new_cell->m_capacity == capacity);
|
||||
unsigned old_sz = a.m_ptr->m_size;
|
||||
new_cell->m_size = old_sz;
|
||||
for (unsigned i = 0; i < old_sz; i++)
|
||||
for (unsigned i = 0; i < old_sz; ++i)
|
||||
new_cell->m_digits[i] = a.m_ptr->m_digits[i];
|
||||
deallocate(a);
|
||||
a.m_ptr = new_cell;
|
||||
|
|
@ -2077,7 +2077,7 @@ void mpz_manager<SYNCH>::machine_div2k(mpz & a, unsigned k) {
|
|||
unsigned i = 0;
|
||||
unsigned j = digit_shift;
|
||||
if (bit_shift != 0) {
|
||||
for (; i < new_sz - 1; i++, j++) {
|
||||
for (; i < new_sz - 1; ++i, ++j) {
|
||||
ds[i] = ds[j];
|
||||
ds[i] >>= bit_shift;
|
||||
ds[i] |= (ds[j+1] << comp_shift);
|
||||
|
|
@ -2086,7 +2086,7 @@ void mpz_manager<SYNCH>::machine_div2k(mpz & a, unsigned k) {
|
|||
ds[i] >>= bit_shift;
|
||||
}
|
||||
else {
|
||||
for (; i < new_sz; i++, j++) {
|
||||
for (; i < new_sz; ++i, ++j) {
|
||||
ds[i] = ds[j];
|
||||
}
|
||||
}
|
||||
|
|
@ -2095,7 +2095,7 @@ void mpz_manager<SYNCH>::machine_div2k(mpz & a, unsigned k) {
|
|||
SASSERT(new_sz == sz);
|
||||
SASSERT(bit_shift != 0);
|
||||
unsigned i = 0;
|
||||
for (; i < new_sz - 1; i++) {
|
||||
for (; i < new_sz - 1; ++i) {
|
||||
ds[i] >>= bit_shift;
|
||||
ds[i] |= (ds[i+1] << comp_shift);
|
||||
}
|
||||
|
|
@ -2136,7 +2136,7 @@ void mpz_manager<SYNCH>::mul2k(mpz & a, unsigned k) {
|
|||
mpz_cell * cell_a = a.m_ptr;
|
||||
old_sz = cell_a->m_size;
|
||||
digit_t * ds = cell_a->m_digits;
|
||||
for (unsigned i = old_sz; i < new_sz; i++)
|
||||
for (unsigned i = old_sz; i < new_sz; ++i)
|
||||
ds[i] = 0;
|
||||
cell_a->m_size = new_sz;
|
||||
|
||||
|
|
@ -2154,13 +2154,13 @@ void mpz_manager<SYNCH>::mul2k(mpz & a, unsigned k) {
|
|||
}
|
||||
if (bit_shift > 0) {
|
||||
DEBUG_CODE({
|
||||
for (unsigned i = 0; i < word_shift; i++) {
|
||||
for (unsigned i = 0; i < word_shift; ++i) {
|
||||
SASSERT(ds[i] == 0);
|
||||
}
|
||||
});
|
||||
unsigned comp_shift = (8 * sizeof(digit_t)) - bit_shift;
|
||||
digit_t prev = 0;
|
||||
for (unsigned i = word_shift; i < new_sz; i++) {
|
||||
for (unsigned i = word_shift; i < new_sz; ++i) {
|
||||
digit_t new_prev = (ds[i] >> comp_shift);
|
||||
ds[i] <<= bit_shift;
|
||||
ds[i] |= prev;
|
||||
|
|
@ -2215,7 +2215,7 @@ unsigned mpz_manager<SYNCH>::power_of_two_multiple(mpz const & a) {
|
|||
unsigned sz = c->m_size;
|
||||
unsigned r = 0;
|
||||
digit_t * source = c->m_digits;
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
if (source[i] != 0) {
|
||||
digit_t v = source[i];
|
||||
if (sizeof(digit_t) == 8) {
|
||||
|
|
@ -2515,7 +2515,7 @@ bool mpz_manager<SYNCH>::decompose(mpz const & a, svector<digit_t> & digits) {
|
|||
#ifndef _MP_GMP
|
||||
mpz_cell * cell_a = a.m_ptr;
|
||||
unsigned sz = cell_a->m_size;
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
digits.push_back(cell_a->m_digits[i]);
|
||||
}
|
||||
return a.m_val < 0;
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ class object_allocator : public ResetProc {
|
|||
|
||||
void call_destructors_for_page(T * page, unsigned end) {
|
||||
T * page_end = page + end;
|
||||
for (; page < page_end; page++)
|
||||
for (; page < page_end; ++page)
|
||||
page->~T();
|
||||
}
|
||||
|
||||
|
|
@ -174,7 +174,7 @@ public:
|
|||
if (num_workers > old_capacity) {
|
||||
m_regions.resize(num_workers);
|
||||
m_free_lists.resize(num_workers);
|
||||
for (unsigned i = old_capacity; i < capacity(); i++) {
|
||||
for (unsigned i = old_capacity; i < capacity(); ++i) {
|
||||
m_regions[i] = alloc(region);
|
||||
}
|
||||
}
|
||||
|
|
@ -194,7 +194,7 @@ public:
|
|||
void reset() {
|
||||
SASSERT(!m_concurrent);
|
||||
unsigned c = capacity();
|
||||
for (unsigned i = 0; i < c; i++) {
|
||||
for (unsigned i = 0; i < c; ++i) {
|
||||
m_regions[i]->reset();
|
||||
m_free_lists[i].reset();
|
||||
}
|
||||
|
|
@ -275,7 +275,7 @@ public:
|
|||
unsigned get_objects_count() const {
|
||||
unsigned count = 0;
|
||||
unsigned n_regions = m_regions.size();
|
||||
for (unsigned i = 0; i < n_regions; i++) {
|
||||
for (unsigned i = 0; i < n_regions; ++i) {
|
||||
count += m_regions[i]->get_objects_count();
|
||||
count -= m_free_lists[i].size();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ std::string norm_param_name(char const* n) {
|
|||
if (sz == 0)
|
||||
return "_";
|
||||
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
char curr = r[i];
|
||||
if ('A' <= curr && curr <= 'Z')
|
||||
r[i] = curr - 'A' + 'a';
|
||||
|
|
@ -173,12 +173,12 @@ struct param_descrs::imp {
|
|||
" ----------|------|-------------|--------\n";
|
||||
}
|
||||
for (symbol const& name : names) {
|
||||
for (unsigned i = 0; i < indent; i++) out << " ";
|
||||
for (unsigned i = 0; i < indent; ++i) out << " ";
|
||||
if (smt2_style)
|
||||
out << ':';
|
||||
std::string s = name.str();
|
||||
unsigned n = static_cast<unsigned>(s.length());
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
if (smt2_style && s[i] == '_')
|
||||
out << '-';
|
||||
else if (!smt2_style && s[i] == '-')
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ private:
|
|||
|
||||
void dec_ref(unsigned sz, value * vs) {
|
||||
if (C::ref_count)
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
m_vmanager.dec_ref(vs[i]);
|
||||
}
|
||||
|
||||
|
|
@ -151,7 +151,7 @@ private:
|
|||
size_t new_capacity = curr_capacity == 0 ? 2 : (3 * curr_capacity + 1) >> 1;
|
||||
value * new_vs = allocate_values(new_capacity);
|
||||
if (curr_capacity > 0) {
|
||||
for (size_t i = 0; i < curr_capacity; i++)
|
||||
for (size_t i = 0; i < curr_capacity; ++i)
|
||||
new_vs[i] = vs[i];
|
||||
deallocate_values(vs);
|
||||
}
|
||||
|
|
@ -197,7 +197,7 @@ private:
|
|||
void copy_values(value * s, unsigned sz, value * & t) {
|
||||
SASSERT(t == 0);
|
||||
t = allocate_values(capacity(s));
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
t[i] = s[i];
|
||||
inc_ref(t[i]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ permutation::permutation(unsigned size) {
|
|||
void permutation::reset(unsigned size) {
|
||||
m_p.reset();
|
||||
m_inv_p.reset();
|
||||
for (unsigned i = 0; i < size; i++) {
|
||||
for (unsigned i = 0; i < size; ++i) {
|
||||
m_p.push_back(i);
|
||||
m_inv_p.push_back(i);
|
||||
}
|
||||
|
|
@ -46,7 +46,7 @@ void permutation::move_after(unsigned i, unsigned j) {
|
|||
if (i >= j)
|
||||
return;
|
||||
unsigned i_prime = m_p[i];
|
||||
for (unsigned k = i; k < j; k++) {
|
||||
for (unsigned k = i; k < j; ++k) {
|
||||
m_p[k] = m_p[k+1];
|
||||
m_inv_p[m_p[k]] = k;
|
||||
}
|
||||
|
|
@ -57,7 +57,7 @@ void permutation::move_after(unsigned i, unsigned j) {
|
|||
|
||||
void permutation::display(std::ostream & out) const {
|
||||
unsigned n = m_p.size();
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
if (i > 0)
|
||||
out << " ";
|
||||
out << i << ":" << m_p[i];
|
||||
|
|
@ -68,7 +68,7 @@ bool permutation::check_invariant() const {
|
|||
SASSERT(m_p.size() == m_inv_p.size());
|
||||
unsigned n = m_p.size();
|
||||
bool_vector check_vector(n, false); // To check for duplicate and out-of-range values
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
unsigned pi = m_p[i];
|
||||
SASSERT(m_p[i] < n);
|
||||
SASSERT(m_inv_p[i] < n);
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ inline std::ostream & operator<<(std::ostream & out, permutation const & p) {
|
|||
template<typename T>
|
||||
void apply_permutation_core(unsigned sz, T * data, unsigned * p) {
|
||||
int * p1 = reinterpret_cast<int*>(p);
|
||||
for (int i = 0; i < static_cast<int>(sz); i++) {
|
||||
for (int i = 0; i < static_cast<int>(sz); ++i) {
|
||||
if (p1[i] < 0)
|
||||
continue; // already processed
|
||||
int j = i;
|
||||
|
|
@ -86,7 +86,7 @@ void apply_permutation(unsigned sz, T * data, unsigned const * p) {
|
|||
apply_permutation_core(sz, data, const_cast<unsigned*>(p));
|
||||
// restore p
|
||||
int * p1 = reinterpret_cast<int*>(const_cast<unsigned*>(p));
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
p1[i] = - p1[i] - 1;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,12 +32,12 @@ void prime_generator::process_next_k_numbers(uint64_t k) {
|
|||
SASSERT(m_primes[j] == 3);
|
||||
while (!todo.empty()) {
|
||||
unsigned sz = m_primes.size();
|
||||
for (; j < sz; j++) {
|
||||
for (; j < sz; ++j) {
|
||||
uint64_t p = m_primes[j];
|
||||
unsigned todo_sz = todo.size();
|
||||
unsigned k1 = 0;
|
||||
unsigned k2 = 0;
|
||||
for (; k1 < todo_sz; k1++) {
|
||||
for (; k1 < todo_sz; ++k1) {
|
||||
if (todo[k1] % p == 0)
|
||||
continue;
|
||||
todo[k2] = todo[k1];
|
||||
|
|
@ -48,7 +48,7 @@ void prime_generator::process_next_k_numbers(uint64_t k) {
|
|||
return;
|
||||
if (p > (todo[k2-1] / p) + 1) {
|
||||
// all numbers in todo are primes
|
||||
for (unsigned k1 = 0; k1 < k2; k1++) {
|
||||
for (unsigned k1 = 0; k1 < k2; ++k1) {
|
||||
m_primes.push_back(todo[k1]);
|
||||
}
|
||||
return;
|
||||
|
|
@ -58,7 +58,7 @@ void prime_generator::process_next_k_numbers(uint64_t k) {
|
|||
p = p*p;
|
||||
unsigned todo_sz = todo.size();
|
||||
unsigned k1 = 0;
|
||||
for (k1 = 0; k1 < todo_sz; k1++) {
|
||||
for (k1 = 0; k1 < todo_sz; ++k1) {
|
||||
if (todo[k1] < p) {
|
||||
m_primes.push_back(todo[k1]);
|
||||
}
|
||||
|
|
@ -67,7 +67,7 @@ void prime_generator::process_next_k_numbers(uint64_t k) {
|
|||
}
|
||||
}
|
||||
unsigned k2 = 0;
|
||||
for (; k1 < todo_sz; k1++, k2++) {
|
||||
for (; k1 < todo_sz; ++k1, ++k2) {
|
||||
todo[k2] = todo[k1];
|
||||
}
|
||||
todo.shrink(k2);
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ static void mk_power_up_to(vector<rational> & pws, unsigned n) {
|
|||
unsigned sz = pws.size();
|
||||
rational curr = pws[sz - 1];
|
||||
rational two(2);
|
||||
for (unsigned i = sz; i <= n; i++) {
|
||||
for (unsigned i = sz; i <= n; ++i) {
|
||||
curr *= two;
|
||||
pws.push_back(curr);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ public:
|
|||
}
|
||||
|
||||
void append(unsigned n, T * const * elems) {
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
push_back(elems[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ public:
|
|||
m_nodes.shrink(sz);
|
||||
}
|
||||
else {
|
||||
for (unsigned i = m_nodes.size(); i < sz; i++)
|
||||
for (unsigned i = m_nodes.size(); i < sz; ++i)
|
||||
push_back(d);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ public:
|
|||
m_nodes.shrink(sz);
|
||||
}
|
||||
else {
|
||||
for (unsigned i = m_nodes.size(); i < sz; i++)
|
||||
for (unsigned i = m_nodes.size(); i < sz; ++i)
|
||||
push_back(d);
|
||||
}
|
||||
}
|
||||
|
|
@ -167,7 +167,7 @@ public:
|
|||
|
||||
void erase(T * elem) {
|
||||
unsigned sz = size();
|
||||
for (unsigned idx = 0; idx < sz; idx++) {
|
||||
for (unsigned idx = 0; idx < sz; ++idx) {
|
||||
if (m_nodes[idx] == elem) {
|
||||
erase(idx);
|
||||
return;
|
||||
|
|
@ -177,7 +177,7 @@ public:
|
|||
|
||||
bool contains(T * elem) const {
|
||||
unsigned sz = size();
|
||||
for (unsigned idx = 0; idx < sz; idx++)
|
||||
for (unsigned idx = 0; idx < sz; ++idx)
|
||||
if (m_nodes[idx] == elem)
|
||||
return true;
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ public:
|
|||
void pop_scope();
|
||||
|
||||
void pop_scope(unsigned num_scopes) {
|
||||
for (unsigned i = 0; i < num_scopes; i++) {
|
||||
for (unsigned i = 0; i < num_scopes; ++i) {
|
||||
pop_scope();
|
||||
}
|
||||
}
|
||||
|
|
@ -79,7 +79,7 @@ public:
|
|||
void push_scope();
|
||||
void pop_scope();
|
||||
void pop_scope(unsigned num_scopes) {
|
||||
for (unsigned i = 0; i < num_scopes; i++) {
|
||||
for (unsigned i = 0; i < num_scopes; ++i) {
|
||||
pop_scope();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ public:
|
|||
friend inline s_integer ceil(const s_integer & r) { return r; }
|
||||
s_integer expt(int n) const {
|
||||
s_integer result(1);
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int i = 0; i < n; ++i) {
|
||||
result *= *this;
|
||||
}
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ namespace sat {
|
|||
};
|
||||
|
||||
inline std::ostream & operator<<(std::ostream & out, mk_lits_pp const & ls) {
|
||||
for (unsigned i = 0; i < ls.m_num; i++) {
|
||||
for (unsigned i = 0; i < ls.m_num; ++i) {
|
||||
if (i > 0) out << " ";
|
||||
out << ls.m_lits[i];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ public:
|
|||
|
||||
void reset() {
|
||||
unsigned sz = this->size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
m().del(this->operator[](i));
|
||||
}
|
||||
super::reset();
|
||||
|
|
@ -51,7 +51,7 @@ public:
|
|||
unsigned old_sz = this->size();
|
||||
if (old_sz == sz)
|
||||
return;
|
||||
for (unsigned i = sz; i < old_sz; i++)
|
||||
for (unsigned i = sz; i < old_sz; ++i)
|
||||
m().del(this->operator[](i));
|
||||
super::shrink(sz);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ public:
|
|||
|
||||
void reset() {
|
||||
auto sz = this->size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
m().del(this->operator[](i));
|
||||
}
|
||||
svector<typename Manager::numeral>::reset();
|
||||
|
|
@ -61,7 +61,7 @@ public:
|
|||
unsigned old_sz = this->size();
|
||||
if (old_sz == sz)
|
||||
return;
|
||||
for (unsigned i = sz; i < old_sz; i++)
|
||||
for (unsigned i = sz; i < old_sz; ++i)
|
||||
m().del(this->operator[](i));
|
||||
svector<typename Manager::numeral>::shrink(sz);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ public:
|
|||
m_vector.shrink(sz);
|
||||
}
|
||||
else {
|
||||
for (unsigned i = m_vector.size(); i < sz; i++)
|
||||
for (unsigned i = m_vector.size(); i < sz; ++i)
|
||||
push_back(nullptr);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ struct sexpr_composite : public sexpr {
|
|||
sexpr_composite(unsigned num_children, sexpr * const * children, unsigned line, unsigned pos):
|
||||
sexpr(kind_t::COMPOSITE, line, pos),
|
||||
m_num_children(num_children) {
|
||||
for (unsigned i = 0; i < num_children; i++) {
|
||||
for (unsigned i = 0; i < num_children; ++i) {
|
||||
m_children[i] = children[i];
|
||||
children[i]->inc_ref();
|
||||
}
|
||||
|
|
@ -226,7 +226,7 @@ void sexpr_manager::del(sexpr * n) {
|
|||
switch (n->get_kind()) {
|
||||
case sexpr::kind_t::COMPOSITE: {
|
||||
unsigned num = n->get_num_children();
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
for (unsigned i = 0; i < num; ++i) {
|
||||
sexpr * child = n->get_child(i);
|
||||
SASSERT(child->m_ref_count > 0);
|
||||
child->m_ref_count--;
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ Revision History:
|
|||
|
||||
|
||||
small_object_allocator::small_object_allocator(char const * id) {
|
||||
for (unsigned i = 0; i < NUM_SLOTS; i++) {
|
||||
for (unsigned i = 0; i < NUM_SLOTS; ++i) {
|
||||
m_chunks[i] = nullptr;
|
||||
m_free_list[i] = nullptr;
|
||||
}
|
||||
|
|
@ -41,7 +41,7 @@ small_object_allocator::small_object_allocator(char const * id) {
|
|||
}
|
||||
|
||||
small_object_allocator::~small_object_allocator() {
|
||||
for (unsigned i = 0; i < NUM_SLOTS; i++) {
|
||||
for (unsigned i = 0; i < NUM_SLOTS; ++i) {
|
||||
chunk * c = m_chunks[i];
|
||||
while (c) {
|
||||
chunk * next = c->m_next;
|
||||
|
|
@ -57,7 +57,7 @@ small_object_allocator::~small_object_allocator() {
|
|||
}
|
||||
|
||||
void small_object_allocator::reset() {
|
||||
for (unsigned i = 0; i < NUM_SLOTS; i++) {
|
||||
for (unsigned i = 0; i < NUM_SLOTS; ++i) {
|
||||
chunk * c = m_chunks[i];
|
||||
while (c) {
|
||||
chunk * next = c->m_next;
|
||||
|
|
@ -148,7 +148,7 @@ void * small_object_allocator::allocate(size_t size) {
|
|||
|
||||
size_t small_object_allocator::get_wasted_size() const {
|
||||
size_t r = 0;
|
||||
for (unsigned slot_id = 0; slot_id < NUM_SLOTS; slot_id++) {
|
||||
for (unsigned slot_id = 0; slot_id < NUM_SLOTS; ++slot_id) {
|
||||
size_t slot_obj_size = slot_id << PTR_ALIGNMENT;
|
||||
void ** ptr = reinterpret_cast<void **>(const_cast<small_object_allocator*>(this)->m_free_list[slot_id]);
|
||||
while (ptr != nullptr) {
|
||||
|
|
@ -161,7 +161,7 @@ size_t small_object_allocator::get_wasted_size() const {
|
|||
|
||||
size_t small_object_allocator::get_num_free_objs() const {
|
||||
size_t r = 0;
|
||||
for (unsigned slot_id = 0; slot_id < NUM_SLOTS; slot_id++) {
|
||||
for (unsigned slot_id = 0; slot_id < NUM_SLOTS; ++slot_id) {
|
||||
void ** ptr = reinterpret_cast<void **>(const_cast<small_object_allocator*>(this)->m_free_list[slot_id]);
|
||||
while (ptr != nullptr) {
|
||||
r ++;
|
||||
|
|
@ -185,7 +185,7 @@ void small_object_allocator::consolidate() {
|
|||
static_cast<double>(memory::get_allocation_size())/static_cast<double>(1024*1024) << ")" << std::endl;);
|
||||
ptr_vector<chunk> chunks;
|
||||
ptr_vector<char> free_objs;
|
||||
for (unsigned slot_id = 1; slot_id < NUM_SLOTS; slot_id++) {
|
||||
for (unsigned slot_id = 1; slot_id < NUM_SLOTS; ++slot_id) {
|
||||
if (m_free_list[slot_id] == nullptr)
|
||||
continue;
|
||||
chunks.reset();
|
||||
|
|
@ -232,7 +232,7 @@ void small_object_allocator::consolidate() {
|
|||
else {
|
||||
curr_chunk->m_next = last_chunk;
|
||||
last_chunk = curr_chunk;
|
||||
for (unsigned i = saved_obj_idx; i < obj_idx; i++) {
|
||||
for (unsigned i = saved_obj_idx; i < obj_idx; ++i) {
|
||||
// relink objects
|
||||
void * free_obj = free_objs[i];
|
||||
*(reinterpret_cast<void**>(free_obj)) = last_free_obj;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ bool is_smt2_quoted_symbol(char const * s) {
|
|||
return true;
|
||||
unsigned len = static_cast<unsigned>(strlen(s));
|
||||
if (len >= 2 && s[0] == '|' && s[len-1] == '|') {
|
||||
for (unsigned i = 1; i + 1 < len; i++) {
|
||||
for (unsigned i = 1; i + 1 < len; ++i) {
|
||||
if (s[i] == '\\' && i + 2 < len && (s[i+1] == '\\' || s[i+1] == '|')) {
|
||||
i++;
|
||||
}
|
||||
|
|
@ -44,7 +44,7 @@ bool is_smt2_quoted_symbol(char const * s) {
|
|||
}
|
||||
return false;
|
||||
}
|
||||
for (unsigned i = 0; i < len; i++)
|
||||
for (unsigned i = 0; i < len; ++i)
|
||||
if (!is_smt2_simple_symbol_char(s[i]))
|
||||
return true;
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ typedef map<char const *, double, str_hash_proc, str_eq_proc> key2dval;
|
|||
|
||||
unsigned get_max_len(ptr_buffer<char> & keys) {
|
||||
unsigned max = 0;
|
||||
for (unsigned i = 0; i < static_cast<unsigned>(keys.size()); i++) {
|
||||
for (unsigned i = 0; i < static_cast<unsigned>(keys.size()); ++i) {
|
||||
char * k = keys.get(i);
|
||||
if (*k == ':')
|
||||
k++;
|
||||
|
|
@ -114,13 +114,13 @@ std::ostream& statistics::display_smt2(std::ostream & out) const {
|
|||
out << "\n "; \
|
||||
display_smt2_key(out, k); \
|
||||
unsigned len = static_cast<unsigned>(strlen(k)); \
|
||||
for (unsigned j = len; j < max; j++) \
|
||||
for (unsigned j = len; j < max; ++j) \
|
||||
out << " "; \
|
||||
first = false; \
|
||||
}
|
||||
|
||||
out << "(";
|
||||
for (unsigned i = 0; i < keys.size(); i++) {
|
||||
for (unsigned i = 0; i < keys.size(); ++i) {
|
||||
char * k = keys.get(i);
|
||||
unsigned val;
|
||||
if (m_u.find(k, val)) {
|
||||
|
|
@ -147,11 +147,11 @@ std::ostream& statistics::display(std::ostream & out) const {
|
|||
k++; \
|
||||
out << k << ":"; \
|
||||
unsigned len = static_cast<unsigned>(strlen(k)); \
|
||||
for (unsigned j = len; j < max; j++) \
|
||||
for (unsigned j = len; j < max; ++j) \
|
||||
out << " "; \
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < keys.size(); i++) {
|
||||
for (unsigned i = 0; i < keys.size(); ++i) {
|
||||
char * k = keys.get(i);
|
||||
unsigned val;
|
||||
if (m_u.find(k, val)) {
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ public:
|
|||
m_trail_lims.pop_back();
|
||||
unsigned curr_size = m_trail_stack.size();
|
||||
SASSERT(old_size <= curr_size);
|
||||
for (unsigned i = old_size; i < curr_size; i++) {
|
||||
for (unsigned i = old_size; i < curr_size; ++i) {
|
||||
key_data & curr_entry = m_trail_stack.back();
|
||||
symbol key = curr_entry.m_key;
|
||||
if (key.is_marked()) {
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ class total_order {
|
|||
curr_gap = ideal_gap;
|
||||
c = a->m_next;
|
||||
uint64_t inc = curr_gap;
|
||||
for (unsigned i = 0; i < j; i++) {
|
||||
for (unsigned i = 0; i < j; ++i) {
|
||||
c->m_val = v0 + inc;
|
||||
c = c->m_next;
|
||||
inc += curr_gap;
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ public:
|
|||
}
|
||||
|
||||
bool empty() const {
|
||||
for (unsigned i = 0; i < size(); i++) {
|
||||
for (unsigned i = 0; i < size(); ++i) {
|
||||
if ((*this)[i] != 0) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -72,7 +72,7 @@ public:
|
|||
|
||||
unsigned num_elems() const {
|
||||
unsigned r = 0;
|
||||
for (unsigned i = 0; i < size(); i++) {
|
||||
for (unsigned i = 0; i < size(); ++i) {
|
||||
r += get_num_1bits((*this)[i]);
|
||||
}
|
||||
return r;
|
||||
|
|
@ -84,7 +84,7 @@ public:
|
|||
if (source_size > size()) {
|
||||
resize(source_size + 1);
|
||||
}
|
||||
for (unsigned i = 0; i < source_size; i++) {
|
||||
for (unsigned i = 0; i < source_size; ++i) {
|
||||
(*this)[i] |= source[i];
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -95,7 +95,7 @@ public:
|
|||
if (source_size < size()) {
|
||||
resize(source_size);
|
||||
}
|
||||
for (unsigned i = 0; i < size(); i++) {
|
||||
for (unsigned i = 0; i < size(); ++i) {
|
||||
(*this)[i] &= source[i];
|
||||
}
|
||||
return *this;
|
||||
|
|
@ -106,7 +106,7 @@ public:
|
|||
if (source.size() < min_size) {
|
||||
min_size = source.size();
|
||||
}
|
||||
for (unsigned i = 0; i < min_size; i++) {
|
||||
for (unsigned i = 0; i < min_size; ++i) {
|
||||
if ((*this)[i] != source[i]) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -135,7 +135,7 @@ public:
|
|||
if (source.size() < min_size) {
|
||||
min_size = source.size();
|
||||
}
|
||||
for (unsigned i = 0; i < min_size; i++) {
|
||||
for (unsigned i = 0; i < min_size; ++i) {
|
||||
if (((*this)[i] & ~source[i]) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -219,7 +219,7 @@ inline std::ostream & operator<<(std::ostream & target, const uint_set & s) {
|
|||
unsigned n = s.get_max_elem() + 1;
|
||||
target << "{";
|
||||
bool first = true;
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
if (s.contains(i)) {
|
||||
if (first) {
|
||||
first = false;
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ public:
|
|||
|
||||
void display(std::ostream & out) const {
|
||||
unsigned num = get_num_vars();
|
||||
for (unsigned v = 0; v < num; v++) {
|
||||
for (unsigned v = 0; v < num; ++v) {
|
||||
out << "v" << v << " --> v" << m_find[v] << " (" << size(v) << ")\n";
|
||||
}
|
||||
}
|
||||
|
|
@ -167,7 +167,7 @@ public:
|
|||
#ifdef Z3DEBUG
|
||||
bool check_invariant() const {
|
||||
unsigned num = get_num_vars();
|
||||
for (unsigned v = 0; v < num; v++) {
|
||||
for (unsigned v = 0; v < num; ++v) {
|
||||
if (is_root(v)) {
|
||||
unsigned curr = v;
|
||||
unsigned sz = 0;
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ unsigned uint64_log2(uint64_t v) {
|
|||
}
|
||||
|
||||
bool product_iterator_next(unsigned n, unsigned const * sz, unsigned * it) {
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
it[i]++;
|
||||
if (it[i] < sz[i])
|
||||
return true;
|
||||
|
|
@ -147,7 +147,7 @@ void escaped::display(std::ostream & out) const {
|
|||
}
|
||||
out << c;
|
||||
if (c == '\n') {
|
||||
for (unsigned i = 0; i < m_indent; i++)
|
||||
for (unsigned i = 0; i < m_indent; ++i)
|
||||
out << " ";
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ static inline unsigned get_num_1bits(unsigned v) {
|
|||
#ifdef Z3DEBUG
|
||||
unsigned c;
|
||||
unsigned v1 = v;
|
||||
for (c = 0; v1; c++) {
|
||||
for (c = 0; v1; ++c) {
|
||||
v1 &= v1 - 1;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -133,7 +133,7 @@ static inline unsigned get_num_1bits(uint64_t v) {
|
|||
#ifdef Z3DEBUG
|
||||
unsigned c;
|
||||
uint64_t v1 = v;
|
||||
for (c = 0; v1; c++) {
|
||||
for (c = 0; v1; ++c) {
|
||||
v1 &= v1 - 1;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -311,7 +311,7 @@ public:
|
|||
|
||||
template<typename T>
|
||||
bool compare_arrays(const T * array1, const T * array2, unsigned size) {
|
||||
for (unsigned i = 0; i < size; i++) {
|
||||
for (unsigned i = 0; i < size; ++i) {
|
||||
if (!(array1[i] == array2[i])) {
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -170,7 +170,7 @@ public:
|
|||
}
|
||||
|
||||
vector(SZ s, T const * data) {
|
||||
for (SZ i = 0; i < s; i++) {
|
||||
for (SZ i = 0; i < s; ++i) {
|
||||
push_back(data[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -195,7 +195,7 @@ public:
|
|||
}
|
||||
if (size() != other.size())
|
||||
return false;
|
||||
for (unsigned i = 0; i < size(); i++) {
|
||||
for (unsigned i = 0; i < size(); ++i) {
|
||||
if ((*this)[i] != other[i])
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue