mirror of
https://github.com/Z3Prover/z3
synced 2026-02-23 00:37:36 +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:
Copilot
Nikolaj Bjorner
parent
851b8ea31c
commit
317dd92105
475 changed files with 3237 additions and 3237 deletions
|
|
@ -190,7 +190,7 @@ void tst_refine_mpbq(int n, int d) {
|
|||
bqm.to_mpbq(q1, l);
|
||||
bqm.set(u, l);
|
||||
bqm.mul2(u);
|
||||
for (unsigned i = 0; i < 20; i++) {
|
||||
for (unsigned i = 0; i < 20; ++i) {
|
||||
std::cout << l << " < " << q1 << " < " << u << "\n";
|
||||
bqm.display_decimal(std::cout, l, 20); std::cout << " < ";
|
||||
qm.display_decimal(std::cout, q1, 20); std::cout << " < ";
|
||||
|
|
@ -201,7 +201,7 @@ void tst_refine_mpbq(int n, int d) {
|
|||
bqm.to_mpbq(q1, l);
|
||||
bqm.set(u, l);
|
||||
bqm.mul2(u);
|
||||
for (unsigned i = 0; i < 20; i++) {
|
||||
for (unsigned i = 0; i < 20; ++i) {
|
||||
std::cout << l << " < " << q1 << " < " << u << "\n";
|
||||
bqm.display_decimal(std::cout, l, 20); std::cout << " < ";
|
||||
qm.display_decimal(std::cout, q1, 20); std::cout << " < ";
|
||||
|
|
@ -230,7 +230,7 @@ static void tst_wilkinson() {
|
|||
polynomial_ref x(m);
|
||||
x = m.mk_polynomial(m.mk_var());
|
||||
polynomial_ref p(m);
|
||||
for (int i = 1; i <= 20; i++) {
|
||||
for (int i = 1; i <= 20; ++i) {
|
||||
if (i > 1)
|
||||
p = p*(x - i);
|
||||
else
|
||||
|
|
@ -244,7 +244,7 @@ static void tst_wilkinson() {
|
|||
am.isolate_roots(p, rs1);
|
||||
display_anums(std::cout, rs1);
|
||||
ENSURE(rs1.size() == 20);
|
||||
for (unsigned i = 0; i < rs1.size(); i++) {
|
||||
for (unsigned i = 0; i < rs1.size(); ++i) {
|
||||
ENSURE(am.is_int(rs1[i]));
|
||||
}
|
||||
}
|
||||
|
|
@ -402,11 +402,11 @@ static void tst_isolate_roots(polynomial_ref const & p, anum_manager & am,
|
|||
am.isolate_roots(p, x2v, roots, signs);
|
||||
ENSURE(roots.size() + 1 == signs.size());
|
||||
std::cout << "roots:\n";
|
||||
for (unsigned i = 0; i < roots.size(); i++) {
|
||||
for (unsigned i = 0; i < roots.size(); ++i) {
|
||||
am.display_root(std::cout, roots[i]); std::cout << " "; am.display_decimal(std::cout, roots[i]); std::cout << "\n";
|
||||
}
|
||||
std::cout << "signs:\n";
|
||||
for (unsigned i = 0; i < signs.size(); i++) {
|
||||
for (unsigned i = 0; i < signs.size(); ++i) {
|
||||
if (i > 0)
|
||||
std::cout << " 0 ";
|
||||
if (signs[i] < 0) std::cout << "-";
|
||||
|
|
@ -484,7 +484,7 @@ static void tst_isolate_roots() {
|
|||
|
||||
static void pp(polynomial_ref const & p, polynomial::var x) {
|
||||
unsigned d = degree(p, x);
|
||||
for (unsigned i = 0; i <= d; i++) {
|
||||
for (unsigned i = 0; i <= d; ++i) {
|
||||
std::cout << "(" << coeff(p, x, i) << ") ";
|
||||
}
|
||||
std::cout << "\n";
|
||||
|
|
|
|||
|
|
@ -173,7 +173,7 @@ void test_ast_map_keys() {
|
|||
|
||||
// Verify all keys are present (order may vary)
|
||||
bool found_x = false, found_y = false, found_z = false;
|
||||
for (unsigned i = 0; i < Z3_ast_vector_size(ctx, keys); i++) {
|
||||
for (unsigned i = 0; i < Z3_ast_vector_size(ctx, keys); ++i) {
|
||||
Z3_ast key = Z3_ast_vector_get(ctx, keys, i);
|
||||
if (Z3_is_eq_ast(ctx, key, x)) found_x = true;
|
||||
if (Z3_is_eq_ast(ctx, key, y)) found_y = true;
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ void mk_bits(ast_manager & m, char const * prefix, unsigned sz, expr_ref_vector
|
|||
}
|
||||
|
||||
void display(std::ostream & out, expr_ref_vector & r, bool ll=true) {
|
||||
for (unsigned i = 0; i < r.size(); i++) {
|
||||
for (unsigned i = 0; i < r.size(); ++i) {
|
||||
out << "bit " << i << ":\n";
|
||||
if (ll)
|
||||
ast_ll_pp(out, r.get_manager(), r.get(i));
|
||||
|
|
@ -50,7 +50,7 @@ static unsigned to_int(model_core & mdl, expr_ref_vector & out) {
|
|||
model_evaluator eval(mdl);
|
||||
expr_ref bit(m);
|
||||
unsigned actual = 0;
|
||||
for (unsigned i = 0; i < out.size(); i++) {
|
||||
for (unsigned i = 0; i < out.size(); ++i) {
|
||||
eval(out.get(i), bit);
|
||||
if (m.is_true(bit))
|
||||
actual |= 1 << i;
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ static void tst1() {
|
|||
bit_vector v1;
|
||||
bool_vector v2;
|
||||
unsigned n = rand()%10000;
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
int op = rand()%6;
|
||||
if (op <= 1) {
|
||||
bool val = (rand()%2) != 0;
|
||||
|
|
@ -53,7 +53,7 @@ static void tst1() {
|
|||
}
|
||||
else if (op <= 5) {
|
||||
ENSURE(v1.size() == v2.size());
|
||||
for (unsigned j = 0; j < v1.size(); j++) {
|
||||
for (unsigned j = 0; j < v1.size(); ++j) {
|
||||
ENSURE(v1.get(j) == v2[j]);
|
||||
}
|
||||
}
|
||||
|
|
@ -307,7 +307,7 @@ void tst_bit_vector() {
|
|||
tst_eq();
|
||||
return;
|
||||
tst2();
|
||||
for (unsigned i = 0; i < 20; i++) {
|
||||
for (unsigned i = 0; i < 20; ++i) {
|
||||
std::cerr << i << std::endl;
|
||||
tst1();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
unsigned dst_sz, unsigned const * dst, bool trace = true) {
|
||||
if (trace) {
|
||||
std::cout << "shl({";
|
||||
for (unsigned i = 0; i < src_sz; i++) {
|
||||
for (unsigned i = 0; i < src_sz; ++i) {
|
||||
if (i > 0) std::cout << ", ";
|
||||
std::cout << src[i];
|
||||
}
|
||||
|
|
@ -24,12 +24,12 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
}
|
||||
svector<unsigned> actual_dst;
|
||||
actual_dst.resize(dst_sz, 0xAAAAAAAA);
|
||||
for (unsigned sz = 1; sz <= dst_sz; sz++) {
|
||||
for (unsigned sz = 1; sz <= dst_sz; ++sz) {
|
||||
if (trace)
|
||||
std::cout << " for sz = " << sz << std::endl;
|
||||
shl(src_sz, src, k, sz, actual_dst.data());
|
||||
ENSURE(!has_one_at_first_k_bits(sz, actual_dst.data(), k));
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
if (trace && dst[i] != actual_dst[i])
|
||||
std::cout << "UNEXPECTED RESULT at [" << i << "]: " << actual_dst[i] << ", expected: " << dst[i] << "\n";
|
||||
ENSURE(dst[i] == actual_dst[i]);
|
||||
|
|
@ -49,7 +49,7 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
svector<unsigned> new_src;
|
||||
new_src.resize(sz, 0xAAAAAAAA);
|
||||
shr(sz, actual_dst.data(), k, new_src.data());
|
||||
for (unsigned i = 0; i < src_sz; i++) {
|
||||
for (unsigned i = 0; i < src_sz; ++i) {
|
||||
if (trace && src[i] != new_src[i]) {
|
||||
std::cout << "shr BUG, inverting shl, at bit[" << i << "], " << new_src[i] << ", expected: " << src[i] << std::endl;
|
||||
}
|
||||
|
|
@ -60,10 +60,10 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
if (trace)
|
||||
std::cout << " shift by 1, k times" << std::endl;
|
||||
copy(src_sz, src, dst_sz, actual_dst.data());
|
||||
for (unsigned i = 0; i < k; i++) {
|
||||
for (unsigned i = 0; i < k; ++i) {
|
||||
shl(dst_sz, actual_dst.data(), 1, dst_sz, actual_dst.data());
|
||||
}
|
||||
for (unsigned i = 0; i < dst_sz; i++) {
|
||||
for (unsigned i = 0; i < dst_sz; ++i) {
|
||||
if (trace && dst[i] != actual_dst[i])
|
||||
std::cout << "UNEXPECTED RESULT at [" << i << "]: " << actual_dst[i] << ", expected: " << dst[i] << "\n";
|
||||
ENSURE(dst[i] == actual_dst[i]);
|
||||
|
|
@ -72,7 +72,7 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
if (trace)
|
||||
std::cout << " self-shl" << std::endl;
|
||||
shl(src_sz, src, k, src_sz, const_cast<unsigned*>(src));
|
||||
for (unsigned i = 0; i < src_sz; i++) {
|
||||
for (unsigned i = 0; i < src_sz; ++i) {
|
||||
if (trace && src[i] != dst[i])
|
||||
std::cout << "UNEXPECTED RESULT at [" << i << "]: " << src[i] << ", expected: " << dst[i] << "\n";
|
||||
ENSURE(src[i] == actual_dst[i]);
|
||||
|
|
@ -123,7 +123,7 @@ static void tst_shr(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
unsigned const * dst, bool trace = true) {
|
||||
if (trace) {
|
||||
std::cout << "shr({";
|
||||
for (unsigned i = 0; i < src_sz; i++) {
|
||||
for (unsigned i = 0; i < src_sz; ++i) {
|
||||
if (i > 0) std::cout << ", ";
|
||||
std::cout << src[i];
|
||||
}
|
||||
|
|
@ -132,7 +132,7 @@ static void tst_shr(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
svector<unsigned> actual_dst;
|
||||
actual_dst.resize(src_sz, 0xAAAAAAAA);
|
||||
shr(src_sz, src, k, actual_dst.data());
|
||||
for (unsigned i = 0; i < src_sz; i++) {
|
||||
for (unsigned i = 0; i < src_sz; ++i) {
|
||||
if (trace && dst[i] != actual_dst[i])
|
||||
std::cout << "UNEXPECTED RESULT at [" << i << "]: " << actual_dst[i] << ", expected: " << dst[i] << "\n";
|
||||
ENSURE(dst[i] == actual_dst[i]);
|
||||
|
|
@ -149,7 +149,7 @@ static void tst_shr() {
|
|||
static void tst_shl_rand(unsynch_mpz_manager & m, unsigned sz, unsigned k, bool trace = true) {
|
||||
// create a random bitvector of of size sz
|
||||
svector<unsigned> src;
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
src.push_back(rand());
|
||||
}
|
||||
// convert src into a mpz number
|
||||
|
|
@ -181,14 +181,14 @@ static void tst_shl_rand(unsynch_mpz_manager & m, unsigned sz, unsigned k, bool
|
|||
dst.push_back(0);
|
||||
dst.push_back(0);
|
||||
unsigned word_shift = (k / 32);
|
||||
for (unsigned i = 0; i < word_shift; i++)
|
||||
for (unsigned i = 0; i < word_shift; ++i)
|
||||
dst.push_back(0);
|
||||
tst_shl(src.size(), src.data(), k, dst.size(), dst.data(), trace);
|
||||
}
|
||||
|
||||
static void tst_shl_rand(unsigned N, unsigned sz, unsigned k, bool trace = false) {
|
||||
unsynch_mpz_manager m;
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
unsigned _sz = rand() % sz;
|
||||
if (_sz == 0)
|
||||
_sz = 1;
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ template<typename T>
|
|||
static void tst4(unsigned num, unsigned N) {
|
||||
int_set s;
|
||||
T t;
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
for (unsigned i = 0; i < num; ++i) {
|
||||
int v = rand() % N;
|
||||
if (rand() % 3 == 2) {
|
||||
TRACE(chashtable, tout << "erase " << v << "\n";);
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ static void STD_CALL on_ctrl_c(int) {
|
|||
#if 0
|
||||
static void display_model(sat::solver const & s) {
|
||||
sat::model const & m = s.get_model();
|
||||
for (unsigned i = 1; i < m.size(); i++) {
|
||||
for (unsigned i = 1; i < m.size(); ++i) {
|
||||
switch (m[i]) {
|
||||
case l_false: std::cout << "-" << i << " "; break;
|
||||
case l_undef: break;
|
||||
|
|
@ -158,7 +158,7 @@ static lbool core_chunking(sat::solver& s, sat::bool_var_vector& vars, sat::lite
|
|||
}
|
||||
sat::model const & m = s.get_model();
|
||||
sat::literal_vector lambda, backbones;
|
||||
for (unsigned i = 0; i < vars.size(); i++) {
|
||||
for (unsigned i = 0; i < vars.size(); ++i) {
|
||||
lambda.push_back(sat::literal(vars[i], m[vars[i]] == l_false));
|
||||
}
|
||||
while (!lambda.empty()) {
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ void tst_dl_context() {
|
|||
const char * test_file = "c:\\tvm\\src\\benchmarks\\datalog\\t0.datalog";
|
||||
|
||||
params_ref params;
|
||||
for(unsigned rel_index=0; rel_index<rel_cnt; rel_index++) {
|
||||
for(unsigned rel_index=0; rel_index<rel_cnt; ++rel_index) {
|
||||
params.set_sym("default_relation", relations[rel_index]);
|
||||
for(int eager_checking=1; eager_checking>=0; eager_checking--) {
|
||||
params.set_bool("eager_emptiness_checking", eager_checking!=0);
|
||||
|
|
|
|||
|
|
@ -92,10 +92,10 @@ void dl_query_test(ast_manager & m, smt_params & fparams, params_ref& params,
|
|||
std::cerr << "Queries on random facts...\n";
|
||||
relation_fact f_b(m);
|
||||
relation_fact f_q(m);
|
||||
for(unsigned attempt=0; attempt<test_count; attempt++) {
|
||||
for(unsigned attempt=0; attempt<test_count; ++attempt) {
|
||||
f_b.reset();
|
||||
f_q.reset();
|
||||
for(unsigned col=0; col<sig_b.size(); col++) {
|
||||
for(unsigned col=0; col<sig_b.size(); ++col) {
|
||||
uint64_t sort_sz;
|
||||
if(!decl_util.try_get_size(sig_q[col], sort_sz)) {
|
||||
warning_msg("cannot get sort size");
|
||||
|
|
@ -171,7 +171,7 @@ void dl_query_test_wpa(smt_params & fparams, params_ref& params) {
|
|||
uint64_t var_sz;
|
||||
TRUSTME( ctx.try_get_sort_constant_count(var_sort, var_sz) );
|
||||
|
||||
for(unsigned attempt=0; attempt<attempts; attempt++) {
|
||||
for(unsigned attempt=0; attempt<attempts; ++attempt) {
|
||||
unsigned el1 = ran()%var_sz;
|
||||
unsigned el2 = ran()%var_sz;
|
||||
|
||||
|
|
@ -238,12 +238,12 @@ void tst_dl_query() {
|
|||
}
|
||||
ctx_base.get_rel_context()->saturate();
|
||||
|
||||
for(unsigned use_restarts=0; use_restarts<=1; use_restarts++) {
|
||||
for(unsigned use_restarts=0; use_restarts<=1; ++use_restarts) {
|
||||
params.set_uint("initial_restart_timeout", use_restarts ? 100 : 0);
|
||||
for(unsigned use_similar=0; use_similar<=1; use_similar++) {
|
||||
for(unsigned use_similar=0; use_similar<=1; ++use_similar) {
|
||||
params.set_uint("similarity_compressor", use_similar != 0);
|
||||
|
||||
for(unsigned use_magic_sets=0; use_magic_sets<=1; use_magic_sets++) {
|
||||
for(unsigned use_magic_sets=0; use_magic_sets<=1; ++use_magic_sets) {
|
||||
stopwatch watch;
|
||||
if (!(use_restarts == 1 && use_similar == 0 && use_magic_sets == 1)) {
|
||||
continue;
|
||||
|
|
|
|||
|
|
@ -14,14 +14,14 @@ void dl_util_two_array_sort() {
|
|||
unsigned a1[num];
|
||||
unsigned a2[num];
|
||||
|
||||
for(unsigned i=0; i<num; i++) {
|
||||
for(unsigned i=0; i<num; ++i) {
|
||||
a1[i]=(i*30)%num;
|
||||
a2[i]=(i*30)%num+3;
|
||||
}
|
||||
|
||||
datalog::sort_two_arrays(num, a1, a2);
|
||||
|
||||
for(unsigned i=0; i<num; i++) {
|
||||
for(unsigned i=0; i<num; ++i) {
|
||||
ENSURE(a2[i]==i+3);
|
||||
}
|
||||
}
|
||||
|
|
@ -43,7 +43,7 @@ void dl_util_cycle_from_permutation() {
|
|||
cycle.reset();
|
||||
datalog::cycle_from_permutation(perm2, cycle);
|
||||
|
||||
for(unsigned i=0; i<len2; i++) {
|
||||
for(unsigned i=0; i<len2; ++i) {
|
||||
ENSURE( (cycle[i]+1)%len2==cycle[(i+1)%len2] );
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ static euf::enode* get_node(euf::egraph& g, arith_util& a, expr* e) {
|
|||
for (expr* arg : *to_app(e))
|
||||
args.push_back(get_node(g, a, arg));
|
||||
n = g.mk(e, 0, args.size(), args.data());
|
||||
g.add_th_var(n, s_var++, a.get_family_id());
|
||||
g.add_th_var(n, ++s_var, a.get_family_id());
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ static euf::enode* get_node(euf::egraph& g, bv_util& b, expr* e) {
|
|||
for (expr* arg : *to_app(e))
|
||||
args.push_back(get_node(g, b, arg));
|
||||
n = g.mk(e, 0, args.size(), args.data());
|
||||
g.add_th_var(n, s_var++, b.get_family_id());
|
||||
g.add_th_var(n, ++s_var, b.get_family_id());
|
||||
return n;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -68,7 +68,7 @@ static void tst2() {
|
|||
int_set h1;
|
||||
safe_int_set h2;
|
||||
int N = rand() % 1000;
|
||||
for (int i = 0; i < N; i++) {
|
||||
for (int i = 0; i < N; ++i) {
|
||||
int v = rand()%1000;
|
||||
if (rand() % 3 == 2) {
|
||||
h1.erase(v);
|
||||
|
|
@ -221,7 +221,7 @@ void test_hashtable_operators() {
|
|||
|
||||
void tst_hashtable() {
|
||||
tst3();
|
||||
for (int i = 0; i < 100; i++)
|
||||
for (int i = 0; i < 100; ++i)
|
||||
tst2();
|
||||
tst1();
|
||||
test_hashtable_constructors();
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ static void tst1() {
|
|||
int_heap h(N);
|
||||
// int_set t;
|
||||
uint_set t;
|
||||
for (int i = 0; i < N * 3; i++) {
|
||||
for (int i = 0; i < N * 3; ++i) {
|
||||
int val = heap_rand() % N;
|
||||
if (!h.contains(val)) {
|
||||
ENSURE(!t.contains(val));
|
||||
|
|
@ -69,7 +69,7 @@ struct lt_proc2 { bool operator()(int v1, int v2) const { ENSURE(v1 < N && v2 <
|
|||
typedef heap<lt_proc2> int_heap2;
|
||||
|
||||
static void init_values() {
|
||||
for (unsigned i = 0; i < N; i++)
|
||||
for (unsigned i = 0; i < N; ++i)
|
||||
g_value[i] = heap_rand();
|
||||
}
|
||||
|
||||
|
|
@ -86,7 +86,7 @@ static void dump_heap(const int_heap2 & h, std::ostream & out) {
|
|||
|
||||
static void tst2() {
|
||||
int_heap2 h(N);
|
||||
for (int i = 0; i < N * 10; i++) {
|
||||
for (int i = 0; i < N * 10; ++i) {
|
||||
|
||||
// if (i % 1 == 0) std::cout << "i: " << i << std::endl;
|
||||
if (i % 1000 == 0) std::cout << "i: " << i << std::endl;
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ void test_horner_high_degree() {
|
|||
|
||||
// Test higher degree polynomial: p(x) = x^5 + x^4 + x^3 + x^2 + x + 1
|
||||
vector<rational> coeffs;
|
||||
for (int i = 0; i <= 5; i++) {
|
||||
for (int i = 0; i <= 5; ++i) {
|
||||
coeffs.push_back(rational(1));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -235,7 +235,7 @@ static void tst_ ## NAME(unsigned N, unsigned magnitude) { \
|
|||
interval_manager<im_default_config> im(rl, nm); \
|
||||
interval a, b, r; \
|
||||
\
|
||||
for (unsigned i = 0; i < N; i++) { \
|
||||
for (unsigned i = 0; i < N; ++i) { \
|
||||
mk_random_interval(im, a, magnitude); \
|
||||
mk_random_interval(im, b, magnitude); \
|
||||
interval_deps_combine_rule deps; \
|
||||
|
|
@ -256,7 +256,7 @@ static void tst_neg(unsigned N, unsigned magnitude) {
|
|||
interval_manager<im_default_config> im(rl, nm);
|
||||
interval a, b, r;
|
||||
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
mk_random_interval(im, a, magnitude);
|
||||
interval_deps_combine_rule deps;
|
||||
im.neg(a, r, deps);
|
||||
|
|
@ -271,7 +271,7 @@ static void tst_pw_2(unsigned N, unsigned magnitude) {
|
|||
interval_manager<im_default_config> im(rl, nm);
|
||||
interval a, b, r;
|
||||
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
mk_random_interval(im, a, magnitude);
|
||||
interval_deps_combine_rule deps;
|
||||
im.power(a, 2, r, deps);
|
||||
|
|
@ -286,7 +286,7 @@ static void tst_pw_3(unsigned N, unsigned magnitude) {
|
|||
interval_manager<im_default_config> im(rl, nm);
|
||||
interval a, b, r;
|
||||
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
mk_random_interval(im, a, magnitude);
|
||||
interval_deps_combine_rule deps;
|
||||
im.power(a, 3, r, deps);
|
||||
|
|
@ -343,7 +343,7 @@ static void tst_inv(unsigned N, unsigned magnitude) {
|
|||
interval_manager<im_default_config> im(rl, nm);
|
||||
interval a, b, r;
|
||||
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
while (true) {
|
||||
mk_random_interval(im, a, magnitude);
|
||||
if (!im.contains_zero(a))
|
||||
|
|
@ -362,7 +362,7 @@ static void tst_div(unsigned N, unsigned magnitude) {
|
|||
interval_manager<im_default_config> im(rl, nm);
|
||||
interval a, b, r;
|
||||
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
mk_random_interval(im, a, magnitude);
|
||||
while (true) {
|
||||
mk_random_interval(im, b, magnitude);
|
||||
|
|
@ -418,7 +418,7 @@ void tst_pi() {
|
|||
unsynch_mpq_manager nm;
|
||||
interval_manager<im_default_config> im(rl, nm);
|
||||
interval r;
|
||||
for (unsigned i = 0; i < 8; i++) {
|
||||
for (unsigned i = 0; i < 8; ++i) {
|
||||
im.pi(i, r);
|
||||
nm.display_decimal(std::cout, im.lower(r), 32); std::cout << " ";
|
||||
nm.display_decimal(std::cout, im.upper(r), 32); std::cout << "\n";
|
||||
|
|
@ -437,7 +437,7 @@ static void tst_pi_float() {
|
|||
interval_manager<im_float_config<mpf_manager> > im(rl, ifc);
|
||||
scoped_mpq q(qm);
|
||||
im_float_config<mpf_manager>::interval r;
|
||||
for (unsigned i = 0; i < 8; i++) {
|
||||
for (unsigned i = 0; i < 8; ++i) {
|
||||
im.pi(i, r);
|
||||
fm.to_rational(im.lower(r), q);
|
||||
qm.display_decimal(std::cout, q, 32); std::cout << " ";
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ class argument_parser {
|
|||
public:
|
||||
std::string m_error_message;
|
||||
argument_parser(unsigned argn, char * const* args) {
|
||||
for (unsigned i = 0; i < argn; i++) {
|
||||
for (unsigned i = 0; i < argn; ++i) {
|
||||
m_args.push_back(std::string(args[i]));
|
||||
}
|
||||
}
|
||||
|
|
@ -61,7 +61,7 @@ public:
|
|||
|
||||
bool parse() {
|
||||
bool status_is_ok = true;
|
||||
for (unsigned i = 0; i < m_args.size(); i++) {
|
||||
for (unsigned i = 0; i < m_args.size(); ++i) {
|
||||
std::string ar = m_args[i];
|
||||
if (m_options.find(ar) != m_options.end() )
|
||||
m_used_options.insert(ar);
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ struct gomory_test {
|
|||
TRACE(gomory_cut_detail, tout << "pol.size() > 1" << std::endl;);
|
||||
lcm_den = lcm(lcm_den, denominator(k));
|
||||
TRACE(gomory_cut_detail, tout << "k: " << k << " lcm_den: " << lcm_den << "\n";
|
||||
for (unsigned i = 0; i < pol.size(); i++) {
|
||||
for (unsigned i = 0; i < pol.size(); ++i) {
|
||||
tout << pol[i].first << " " << pol[i].second << "\n";
|
||||
}
|
||||
tout << "k: " << k << "\n";);
|
||||
|
|
@ -172,7 +172,7 @@ struct gomory_test {
|
|||
k *= lcm_den;
|
||||
}
|
||||
TRACE(gomory_cut_detail, tout << "after *lcm\n";
|
||||
for (unsigned i = 0; i < pol.size(); i++) {
|
||||
for (unsigned i = 0; i < pol.size(); ++i) {
|
||||
tout << pol[i].first << " * v" << pol[i].second << "\n";
|
||||
}
|
||||
tout << "k: " << k << "\n";);
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ void test_patching();
|
|||
bool my_white_space(const char &a) { return a == ' ' || a == '\t'; }
|
||||
size_t number_of_whites(const std::string &s) {
|
||||
size_t i = 0;
|
||||
for (; i < s.size(); i++)
|
||||
for (; i < s.size(); ++i)
|
||||
if (!my_white_space(s[i]))
|
||||
return i;
|
||||
return i;
|
||||
|
|
@ -144,7 +144,7 @@ void test_nex_order() {
|
|||
enable_trace("nla_test");
|
||||
nex_creator r;
|
||||
r.set_number_of_vars(3);
|
||||
for (unsigned j = 0; j < r.get_number_of_vars(); j++)
|
||||
for (unsigned j = 0; j < r.get_number_of_vars(); ++j)
|
||||
r.set_var_weight(j, 10 - j);
|
||||
nex_var *a = r.mk_var(0);
|
||||
nex_var *b = r.mk_var(1);
|
||||
|
|
@ -197,7 +197,7 @@ void test_simplify() {
|
|||
enable_trace("nla_test");
|
||||
|
||||
r.set_number_of_vars(3);
|
||||
for (unsigned j = 0; j < r.get_number_of_vars(); j++)
|
||||
for (unsigned j = 0; j < r.get_number_of_vars(); ++j)
|
||||
r.set_var_weight(j, j);
|
||||
nex_var *a = r.mk_var(0);
|
||||
nex_var *b = r.mk_var(1);
|
||||
|
|
@ -277,7 +277,7 @@ void test_cn_shorter() {
|
|||
// // enable_trace("nla_cn_details_");
|
||||
// enable_trace("nla_test_details");
|
||||
// cr.set_number_of_vars(20);
|
||||
// for (unsigned j = 0; j < cr.get_number_of_vars(); j++)
|
||||
// for (unsigned j = 0; j < cr.get_number_of_vars(); ++j)
|
||||
// cr.set_var_weight(j,j);
|
||||
|
||||
// nex_var* a = cr.mk_var(0);
|
||||
|
|
@ -320,7 +320,7 @@ void test_cn() {
|
|||
// // enable_trace("nla_cn");
|
||||
// // enable_trace("nla_test_details");
|
||||
// cr.set_number_of_vars(20);
|
||||
// for (unsigned j = 0; j < cr.get_number_of_vars(); j++)
|
||||
// for (unsigned j = 0; j < cr.get_number_of_vars(); ++j)
|
||||
// cr.set_var_weight(j, j);
|
||||
|
||||
// nex_var* a = cr.mk_var(0);
|
||||
|
|
@ -389,7 +389,7 @@ void init_basic_part_of_basis_heading(vector<unsigned> &basis,
|
|||
vector<int> &basis_heading) {
|
||||
SASSERT(basis_heading.size() >= basis.size());
|
||||
unsigned m = basis.size();
|
||||
for (unsigned i = 0; i < m; i++) {
|
||||
for (unsigned i = 0; i < m; ++i) {
|
||||
unsigned column = basis[i];
|
||||
basis_heading[column] = i;
|
||||
}
|
||||
|
|
@ -643,7 +643,7 @@ char *find_home_dir() {
|
|||
|
||||
template <typename T>
|
||||
void print_chunk(T *arr, unsigned len) {
|
||||
for (unsigned i = 0; i < len; i++) {
|
||||
for (unsigned i = 0; i < len; ++i) {
|
||||
std::cout << arr[i] << ", ";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
|
|
@ -1096,20 +1096,20 @@ void test_rationals_no_numeric_pairs() {
|
|||
stopwatch sw;
|
||||
|
||||
vector<mpq> c;
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
c.push_back(mpq(my_random() % 100, 1 + my_random() % 100));
|
||||
|
||||
vector<mpq> x;
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
x.push_back(mpq(my_random() % 100, 1 + my_random() % 100));
|
||||
|
||||
unsigned k = 500000;
|
||||
mpq r = zero_of_type<mpq>();
|
||||
sw.start();
|
||||
|
||||
for (unsigned j = 0; j < k; j++) {
|
||||
for (unsigned j = 0; j < k; ++j) {
|
||||
mpq val = zero_of_type<mpq>();
|
||||
for (unsigned j = 0; j < c.size(); j++) {
|
||||
for (unsigned j = 0; j < c.size(); ++j) {
|
||||
val += c[j] * x[j];
|
||||
}
|
||||
|
||||
|
|
@ -1126,20 +1126,20 @@ void test_rationals_no_numeric_pairs_plus() {
|
|||
stopwatch sw;
|
||||
|
||||
vector<mpq> c;
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
c.push_back(mpq(my_random() % 100, 1 + my_random() % 100));
|
||||
|
||||
vector<mpq> x;
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
x.push_back(mpq(my_random() % 100, 1 + my_random() % 100));
|
||||
|
||||
unsigned k = 500000;
|
||||
mpq r = zero_of_type<mpq>();
|
||||
sw.start();
|
||||
|
||||
for (unsigned j = 0; j < k; j++) {
|
||||
for (unsigned j = 0; j < k; ++j) {
|
||||
mpq val = zero_of_type<mpq>();
|
||||
for (unsigned j = 0; j < c.size(); j++) {
|
||||
for (unsigned j = 0; j < c.size(); ++j) {
|
||||
val = val + c[j] * x[j];
|
||||
}
|
||||
|
||||
|
|
@ -1156,11 +1156,11 @@ void test_rationals() {
|
|||
stopwatch sw;
|
||||
|
||||
vector<rational> c;
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
c.push_back(rational(my_random() % 100, 1 + my_random() % 100));
|
||||
|
||||
vector<numeric_pair<rational>> x;
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
x.push_back(numeric_pair<rational>(
|
||||
rational(my_random() % 100, 1 + my_random() % 100)));
|
||||
|
||||
|
|
@ -1171,8 +1171,8 @@ void test_rationals() {
|
|||
numeric_pair<rational> r = zero_of_type<numeric_pair<rational>>();
|
||||
sw.start();
|
||||
|
||||
for (unsigned j = 0; j < k; j++) {
|
||||
for (unsigned i = 0; i < c.size(); i++) {
|
||||
for (unsigned j = 0; j < k; ++j) {
|
||||
for (unsigned i = 0; i < c.size(); ++i) {
|
||||
r += c[i] * x[i];
|
||||
}
|
||||
}
|
||||
|
|
@ -1427,8 +1427,8 @@ void cutting_the_mix_example_1() {
|
|||
void fill_general_matrix(general_matrix &M) {
|
||||
unsigned m = M.row_count();
|
||||
unsigned n = M.column_count();
|
||||
for (unsigned i = 0; i < m; i++)
|
||||
for (unsigned j = 0; j < n; j++)
|
||||
for (unsigned i = 0; i < m; ++i)
|
||||
for (unsigned j = 0; j < n; ++j)
|
||||
M[i][j] = mpq(static_cast<int>(my_random() % 13) - 6);
|
||||
}
|
||||
|
||||
|
|
@ -1724,7 +1724,7 @@ void test_hnf() {
|
|||
test_hnf_5_5();
|
||||
test_hnf_2_2();
|
||||
for (unsigned k = 1000; k > 0; k--)
|
||||
for (int i = 1; i < 8; i++)
|
||||
for (int i = 1; i < 8; ++i)
|
||||
test_hnf_for_dim(i);
|
||||
cutting_the_mix_example_1();
|
||||
// test_hnf_m_less_than_n();
|
||||
|
|
@ -2009,7 +2009,7 @@ void test_patching() {
|
|||
// repeat the test 100 times
|
||||
|
||||
int range = 40;
|
||||
for (int i = 0; i < 100; i++) {
|
||||
for (int i = 0; i < 100; ++i) {
|
||||
int a1;
|
||||
int a2 = std::max((int)rand() % range, (int)range / 3);
|
||||
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ namespace nla {
|
|||
|
||||
svector<lpvar> get_monic(int monic_size, int var_bound, random_gen& rand) {
|
||||
svector<lpvar> v;
|
||||
for (int i = 0; i < monic_size; i++) {
|
||||
for (int i = 0; i < monic_size; ++i) {
|
||||
lpvar j = rand() % var_bound;
|
||||
v.push_back(j);
|
||||
}
|
||||
|
|
@ -48,7 +48,7 @@ void test_monics_on_setup(int n_of_monics ,
|
|||
var_eqs<emonics> & var_eqs,
|
||||
emonics& ms, random_gen & rand) {
|
||||
int i;
|
||||
for ( i = 0; i < n_of_monics; i++) {
|
||||
for ( i = 0; i < n_of_monics; ++i) {
|
||||
int size = min_monic_size + rand() % (max_monic_size - min_monic_size);
|
||||
ms.add(n_of_vars + i, get_monic(size, n_of_vars, rand));
|
||||
}
|
||||
|
|
@ -56,7 +56,7 @@ void test_monics_on_setup(int n_of_monics ,
|
|||
ms.add(n_of_vars + i, ms[n_of_vars + i - 1].vars());
|
||||
int eqs_left = number_of_eqs;
|
||||
int add_max_var = 4;
|
||||
for (int i = 0; i < number_of_pushes; i++) {
|
||||
for (int i = 0; i < number_of_pushes; ++i) {
|
||||
ms.push();
|
||||
if (eqs_left > 0) {
|
||||
if( i < number_of_pushes - 1) {
|
||||
|
|
@ -620,7 +620,7 @@ void test_order_lemma_params(bool var_equiv, int sign) {
|
|||
lpvar lp_abef = s.add_named_var(abef, true, "abef");
|
||||
lpvar lp_cdij = s.add_named_var(cdij, true, "cdij");
|
||||
|
||||
for (unsigned j = 0; j < s.number_of_vars(); j++) {
|
||||
for (unsigned j = 0; j < s.number_of_vars(); ++j) {
|
||||
s_set_column_value_test(s, j, rational(j + 2));
|
||||
}
|
||||
|
||||
|
|
@ -752,7 +752,7 @@ void test_monotone_lemma() {
|
|||
lpvar lp_cd = s.add_named_var(cd, true, "cd");
|
||||
lpvar lp_ef = s.add_named_var(ef, true, "ef");
|
||||
lpvar lp_ij = s.add_named_var(ij, true, "ij");
|
||||
for (unsigned j = 0; j < s.number_of_vars(); j++) {
|
||||
for (unsigned j = 0; j < s.number_of_vars(); ++j) {
|
||||
s_set_column_value_test(s, j, rational((j + 2)*(j + 2)));
|
||||
}
|
||||
|
||||
|
|
@ -871,7 +871,7 @@ void test_tangent_lemma_equiv() {
|
|||
// lpvar lp_j = s.add_named_var(j, true, "j");
|
||||
lpvar lp_ab = s.add_named_var(ab, true, "ab");
|
||||
int sign = 1;
|
||||
for (unsigned j = 0; j < s.number_of_vars(); j++) {
|
||||
for (unsigned j = 0; j < s.number_of_vars(); ++j) {
|
||||
sign *= -1;
|
||||
s_set_column_value_test(s, j, sign * rational((j + 2) * (j + 2)));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
void tst_##MODULE(); \
|
||||
if (do_display_usage) \
|
||||
std::cout << " " << #MODULE << "\n"; \
|
||||
for (int i = 0; i < argc; i++) \
|
||||
for (int i = 0; i < argc; ++i) \
|
||||
if (test_all || strcmp(argv[i], #MODULE) == 0) { \
|
||||
enable_debug(#MODULE); \
|
||||
timeit timeit(true, s.c_str()); \
|
||||
|
|
@ -38,7 +38,7 @@
|
|||
void tst_##MODULE(char** argv, int argc, int& i); \
|
||||
if (do_display_usage) \
|
||||
std::cout << " " << #MODULE << "(...)\n"; \
|
||||
for (int i = 0; i < argc; i++) \
|
||||
for (int i = 0; i < argc; ++i) \
|
||||
if (strcmp(argv[i], #MODULE) == 0) { \
|
||||
enable_trace(#MODULE); \
|
||||
enable_debug(#MODULE); \
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ void tst_match(ast_manager & m, app * t, app * i) {
|
|||
std::cout << "Are the arguments of " << mk_pp(i, m) << " an instance of the arguments of " << mk_pp(t, m) << "\n";
|
||||
unsigned num_args = t->get_num_args();
|
||||
unsigned j;
|
||||
for (j = 0; j < num_args; j++) {
|
||||
for (j = 0; j < num_args; ++j) {
|
||||
if (!match(t->get_arg(j), i->get_arg(j), s))
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ static void tst1() {
|
|||
m.set(b, -33);
|
||||
std::cout << "a: " << a << ", b: " << b << "\n";
|
||||
std::cout << "a*b: " << a*b << "\n";
|
||||
for (unsigned i = 0; i < 100; i++) {
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
a = a*a;
|
||||
std::cout << i << ": " << a << "\n";
|
||||
}
|
||||
|
|
@ -155,7 +155,7 @@ MK_BIN_OP(div);
|
|||
|
||||
#define MK_BIN_RANDOM_TST(OP) \
|
||||
static void tst_ ## OP(unsigned N, unsigned max, unsigned prec = 2, bool is_div = false) { \
|
||||
for (unsigned i = 0; i < N; i++) { \
|
||||
for (unsigned i = 0; i < N; ++i) { \
|
||||
int n1 = rand() % max; \
|
||||
int d1 = rand() % max + 1; \
|
||||
int n2 = rand() % max; \
|
||||
|
|
@ -250,7 +250,7 @@ static void tst_set64(unsigned N, unsigned prec) {
|
|||
ENSURE(fm.is_uint64(a));
|
||||
ENSURE(!fm.is_int64(a));
|
||||
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
{
|
||||
uint64_t v = (static_cast<uint64_t>(rand()) << 32) + static_cast<uint64_t>(rand());
|
||||
fm.set(a, v);
|
||||
|
|
@ -281,14 +281,14 @@ static void tst_capacity(unsigned prec = 2) {
|
|||
mpff_manager m(prec);
|
||||
scoped_mpff_vector v(m);
|
||||
scoped_mpff a(m);
|
||||
for (unsigned i = 0; i < 50000; i++) {
|
||||
for (unsigned i = 0; i < 50000; ++i) {
|
||||
m.set(a, i);
|
||||
v.push_back(a);
|
||||
ENSURE(m.is_int(v.back()));
|
||||
ENSURE(m.is_int64(v.back()));
|
||||
ENSURE(m.is_uint64(v.back()));
|
||||
}
|
||||
for (unsigned i = 0; i < 50000; i++) {
|
||||
for (unsigned i = 0; i < 50000; ++i) {
|
||||
ENSURE(m.get_int64(v[i]) == i);
|
||||
}
|
||||
}
|
||||
|
|
@ -486,7 +486,7 @@ static void tst_limits(unsigned prec) {
|
|||
ENSURE(!m.is_plus_epsilon(a));
|
||||
ENSURE(m.is_minus_epsilon(a));
|
||||
|
||||
for (unsigned i = 0; i < 2; i++) {
|
||||
for (unsigned i = 0; i < 2; ++i) {
|
||||
m.set_rounding(i == 0);
|
||||
|
||||
m.set_plus_epsilon(a);
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ static void mk_random_num_str(unsigned buffer_sz, char * buffer) {
|
|||
div_pos++;
|
||||
}
|
||||
ENSURE(sz < buffer_sz);
|
||||
for (unsigned i = 0; i < sz-1; i++) {
|
||||
for (unsigned i = 0; i < sz-1; ++i) {
|
||||
if (i == div_pos && i < sz-2) {
|
||||
buffer[i] = '/';
|
||||
i++;
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ static void tst2b() {
|
|||
static void mk_random_num_str(unsigned buffer_sz, char * buffer) {
|
||||
unsigned sz = (rand() % (buffer_sz-2)) + 1;
|
||||
ENSURE(sz < buffer_sz);
|
||||
for (unsigned i = 0; i < sz-1; i++) {
|
||||
for (unsigned i = 0; i < sz-1; ++i) {
|
||||
buffer[i] = '0' + (rand() % 10);
|
||||
}
|
||||
if (rand() % 2 == 0)
|
||||
|
|
@ -328,7 +328,7 @@ unsigned g_primes[NUM_PRIMES] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41
|
|||
void mk_big_num(unsynch_mpz_manager & m, unsigned ratio, unsigned max_pw, mpz & r) {
|
||||
scoped_mpz tmp(m);
|
||||
m.set(r, 1);
|
||||
for (unsigned i = 0; i < NUM_PRIMES; i++) {
|
||||
for (unsigned i = 0; i < NUM_PRIMES; ++i) {
|
||||
if ((rand() % ratio) == 0) {
|
||||
m.power(mpz(g_primes[i]), (rand() % max_pw) + 1, tmp);
|
||||
m.mul(r, tmp, r);
|
||||
|
|
@ -370,7 +370,7 @@ void rand_tst_gcd(unsigned num, unsigned ratio, unsigned pw) {
|
|||
scoped_mpz g1(m);
|
||||
scoped_mpz g2(m);
|
||||
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
for (unsigned i = 0; i < num; ++i) {
|
||||
mk_big_num(m, ratio, pw, a);
|
||||
mk_big_num(m, ratio, pw, b);
|
||||
slow_gcd(m, a, b, g1);
|
||||
|
|
@ -398,7 +398,7 @@ void tst_gcd() {
|
|||
std::cout << "g: " << m.to_string(g) << "\n";
|
||||
m.set(a, "664877781119188360263909568610284290708591605105963082581413244598320881431041311468785283029437655134762231312337924555674674176");
|
||||
m.set(b, "21691055098083293041646678174999125628463716392747356050705870375852789453851926624107939885328471215366825649627326658281728580399051770334114658498352848410853519374962852431831492868108719406669605254329669417322836882756478295264");
|
||||
for (unsigned i = 0; i < 50000; i++) {
|
||||
for (unsigned i = 0; i < 50000; ++i) {
|
||||
m.del(g);
|
||||
m.gcd(a, b, g);
|
||||
// slow_gcd(m, a, b, g);
|
||||
|
|
@ -428,13 +428,13 @@ void tst_log2(unsynch_mpz_manager & m, mpz const & a) {
|
|||
|
||||
void tst_log2() {
|
||||
unsynch_mpz_manager m;
|
||||
for (unsigned i = 0; i <= 64; i++)
|
||||
for (unsigned i = 0; i <= 64; ++i)
|
||||
std::cout << "log2(" << i << "): " << m.log2(mpz(i)) << "\n";
|
||||
for (unsigned i = 0; i < 1000; i++)
|
||||
for (unsigned i = 0; i < 1000; ++i)
|
||||
tst_log2(m, mpz(i));
|
||||
scoped_mpz a(m);
|
||||
m.set(a, "1029489380487098723984579237");
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
m.inc(a);
|
||||
tst_log2(m, a);
|
||||
}
|
||||
|
|
@ -498,7 +498,7 @@ static void tst5() {
|
|||
static void tst_pw2() {
|
||||
unsynch_mpz_manager m;
|
||||
scoped_mpz a(m);
|
||||
for (unsigned i = 0; i < 128; i++) {
|
||||
for (unsigned i = 0; i < 128; ++i) {
|
||||
m.power(mpz(2), i, a);
|
||||
std::cout << "i: " << i << ", a: " << a << std::endl;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ static nlsat::interval_set_ref mk_random(nlsat::interval_set_manager & ism, anum
|
|||
prev = next;
|
||||
}
|
||||
|
||||
for (int i = 0; i < tries; i++) {
|
||||
for (int i = 0; i < tries; ++i) {
|
||||
int l = prev + (gen() % space);
|
||||
int u = l + (gen() % space);
|
||||
bool lower_open = gen() % 2 == 0;
|
||||
|
|
@ -231,7 +231,7 @@ static void check_subset_result(nlsat::interval_set_ref const & s1,
|
|||
ptr_vector<nlsat::clause> clauses;
|
||||
ism.get_justifications(r, lits, clauses);
|
||||
ENSURE(lits.size() <= 2);
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
for (unsigned i = 0; i < num; ++i) {
|
||||
tmp = ism.get_interval(r, i);
|
||||
ism.get_justifications(tmp, lits, clauses);
|
||||
ENSURE(lits.size() == 1);
|
||||
|
|
@ -257,14 +257,14 @@ static void tst4() {
|
|||
nlsat::literal l1(1, false);
|
||||
nlsat::literal l2(2, false);
|
||||
|
||||
for (unsigned i = 0; i < 100; i++) {
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
s1 = mk_random(ism, am, 20, 3, 10, true, true, l1);
|
||||
s2 = mk_random(ism, am, 20, 3, 10, true, true, l2);
|
||||
r = tst_interval(s1, s2, 0, false);
|
||||
check_subset_result(s1, s2, r, l1, l2);
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < 100; i++) {
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
s1 = mk_random(ism, am, 200, 100, 20, true, true, l1);
|
||||
s2 = mk_random(ism, am, 200, 100, 20, true, true, l2);
|
||||
r = tst_interval(s1, s2, 0, false);
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@ static void tst2() {
|
|||
vector<std::pair<cell *, int> > object_coeff_pairs;
|
||||
unsigned num_resets = 0;
|
||||
|
||||
for (unsigned i = 0; i < 100000; i++) {
|
||||
for (unsigned i = 0; i < 100000; ++i) {
|
||||
unsigned idx = rand() % 6;
|
||||
if (idx < 4) {
|
||||
cell * c;
|
||||
|
|
|
|||
|
|
@ -99,11 +99,11 @@ static void tst2() {
|
|||
int_array a1;
|
||||
int_array a2;
|
||||
|
||||
for (unsigned i = 0; i < 100; i++)
|
||||
for (unsigned i = 0; i < 100; ++i)
|
||||
m.push_back(a1, i);
|
||||
ENSURE(m.size(a1) == 100);
|
||||
m.push_back(a1, 100, a2);
|
||||
for (unsigned i = 0; i < 10; i++)
|
||||
for (unsigned i = 0; i < 10; ++i)
|
||||
m.push_back(a2, i+101);
|
||||
TRACE(parray,
|
||||
m.display_info(tout, a1); tout << "\n";
|
||||
|
|
@ -112,10 +112,10 @@ static void tst2() {
|
|||
TRACE(parray,
|
||||
m.display_info(tout, a1); tout << "\n";
|
||||
m.display_info(tout, a2); tout << "\n";);
|
||||
for (unsigned i = 0; i < m.size(a1); i++) {
|
||||
for (unsigned i = 0; i < m.size(a1); ++i) {
|
||||
ENSURE(static_cast<unsigned>(m.get(a1, i)) == i);
|
||||
}
|
||||
for (unsigned i = 0; i < m.size(a2); i++) {
|
||||
for (unsigned i = 0; i < m.size(a2); ++i) {
|
||||
ENSURE(static_cast<unsigned>(m.get(a2, i)) == i);
|
||||
}
|
||||
TRACE(parray,
|
||||
|
|
@ -144,11 +144,11 @@ static void tst3() {
|
|||
int_array a3;
|
||||
int_array a4;
|
||||
|
||||
for (unsigned i = 0; i < 20; i++)
|
||||
for (unsigned i = 0; i < 20; ++i)
|
||||
m.push_back(a1, i);
|
||||
ENSURE(m.size(a1) == 20);
|
||||
m.set(a1, 0, 1, a2);
|
||||
for (unsigned i = 1; i < 20; i++) {
|
||||
for (unsigned i = 1; i < 20; ++i) {
|
||||
if (i == 6) {
|
||||
m.copy(a2, a3);
|
||||
m.pop_back(a3);
|
||||
|
|
@ -161,7 +161,7 @@ static void tst3() {
|
|||
m.pop_back(a4);
|
||||
m.push_back(a4, 30);
|
||||
|
||||
for (unsigned i = 0; i < 20; i++) {
|
||||
for (unsigned i = 0; i < 20; ++i) {
|
||||
ENSURE(static_cast<unsigned>(m.get(a2, i)) == i+1);
|
||||
}
|
||||
TRACE(parray,
|
||||
|
|
@ -182,7 +182,7 @@ static void tst3() {
|
|||
ENSURE(m.size(a2) == 20);
|
||||
ENSURE(m.size(a3) == 19);
|
||||
ENSURE(m.size(a4) == 19);
|
||||
for (unsigned i = 0; i < 20; i++) {
|
||||
for (unsigned i = 0; i < 20; ++i) {
|
||||
ENSURE(static_cast<unsigned>(m.get(a1, i)) == i);
|
||||
ENSURE(static_cast<unsigned>(m.get(a2, i)) == i+1);
|
||||
ENSURE(i >= 18 || static_cast<unsigned>(m.get(a4, i)) == i+1);
|
||||
|
|
@ -282,7 +282,7 @@ static void tst5() {
|
|||
expr_array a2;
|
||||
|
||||
m.mk(a1);
|
||||
for (unsigned i = 0; i < 100; i++) {
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
m.push_back(a1, m.mk_var(i, m.mk_bool_sort()));
|
||||
}
|
||||
|
||||
|
|
@ -291,7 +291,7 @@ static void tst5() {
|
|||
|
||||
m.copy(a1, a2);
|
||||
|
||||
for (unsigned i = 0; i < 1000000; i++) {
|
||||
for (unsigned i = 0; i < 1000000; ++i) {
|
||||
m.set(a1, i % 100, m.mk_var(rand() % 100, m.mk_bool_sort()));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -95,7 +95,7 @@ public:
|
|||
pdd d = m.mk_var(3);
|
||||
|
||||
pdd e = a + c;
|
||||
for (unsigned i = 0; i < 5; i++) {
|
||||
for (unsigned i = 0; i < 5; ++i) {
|
||||
e = e * e;
|
||||
}
|
||||
e = e * b;
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ static void test_move_after() {
|
|||
}
|
||||
|
||||
void apply_permutation_copy(unsigned sz, unsigned const * src, unsigned const * p, unsigned * target) {
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
target[i] = src[p[i]];
|
||||
}
|
||||
}
|
||||
|
|
@ -57,16 +57,16 @@ static void test_apply_permutation(unsigned sz, unsigned num_tries, unsigned max
|
|||
p.resize(sz);
|
||||
new_data.resize(sz);
|
||||
random_gen g;
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
p[i] = i;
|
||||
// fill data with random numbers
|
||||
for (unsigned i = 0; i < sz; i++)
|
||||
for (unsigned i = 0; i < sz; ++i)
|
||||
data[i] = g() % max;
|
||||
for (unsigned k = 0; k < num_tries; k ++) {
|
||||
shuffle(p.size(), p.data(), g);
|
||||
apply_permutation_copy(sz, data.data(), p.data(), new_data.data());
|
||||
apply_permutation(sz, data.data(), p.data());
|
||||
for (unsigned i = 0; i < 0; i++)
|
||||
for (unsigned i = 0; i < 0; ++i)
|
||||
ENSURE(data[i] == new_data[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -708,7 +708,7 @@ static void tst_psc(polynomial_ref const & p, polynomial_ref const & q, polynomi
|
|||
std::cout << "q: " << q << std::endl;
|
||||
m.psc_chain(p, q, x, S);
|
||||
unsigned sz = S.size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
std::cout << "S_" << i << ": " << polynomial_ref(S.get(i), m) << std::endl;
|
||||
}
|
||||
if (sz > 0) {
|
||||
|
|
@ -733,7 +733,7 @@ static void tst_psc_perf(polynomial_ref const & p, polynomial_ref const & q, pol
|
|||
std::cout << "q: " << q << std::endl;
|
||||
m.psc_chain(p, q, x, S);
|
||||
unsigned sz = S.size();
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
std::cout << "S_" << i << ": " << m.size(S.get(i)) << std::endl; // polynomial_ref(S.get(i), m) << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -840,14 +840,14 @@ static void tst_vars(polynomial_ref const & p, unsigned sz, polynomial::var * xs
|
|||
p.m().vars(p, r);
|
||||
std::cout << "---------------\n";
|
||||
std::cout << "p: " << p << "\nvars: ";
|
||||
for (unsigned i = 0; i < r.size(); i++) {
|
||||
for (unsigned i = 0; i < r.size(); ++i) {
|
||||
std::cout << r[i] << " ";
|
||||
}
|
||||
std::cout << std::endl;
|
||||
ENSURE(r.size() == sz);
|
||||
std::sort(r.begin(), r.end());
|
||||
std::sort(xs, xs + sz);
|
||||
for (unsigned i = 0; i < r.size(); i++) {
|
||||
for (unsigned i = 0; i < r.size(); ++i) {
|
||||
ENSURE(r[i] == xs[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -1022,7 +1022,7 @@ void tst_mfact(polynomial_ref const & p, unsigned num_distinct_factors) {
|
|||
factor(p, fs);
|
||||
std::cout << "factors:\n";
|
||||
std::cout << p.m().m().to_string(fs.get_constant()) << "\n";
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); i++) {
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); ++i) {
|
||||
std::cout << "*(" << fs[i] << ")^" << fs.get_degree(i) << std::endl;
|
||||
}
|
||||
ENSURE(fs.distinct_factors() == num_distinct_factors);
|
||||
|
|
@ -1571,7 +1571,7 @@ static void tst_gcd2() {
|
|||
// polynomial_ref p1(m);
|
||||
// p1 = derivative(p, 0);
|
||||
// polynomial_ref g(m);
|
||||
// for (unsigned i = 0; i < 50; i++)
|
||||
// for (unsigned i = 0; i < 50; ++i)
|
||||
// g = gcd(p, p1);
|
||||
// return;
|
||||
|
||||
|
|
|
|||
|
|
@ -133,7 +133,7 @@ void test_factorization_repeated_factors() {
|
|||
|
||||
// Check that factor has degree 3 (meaning (x-1)^3)
|
||||
unsigned total_degree = 0;
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); i++) {
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); ++i) {
|
||||
total_degree += m.degree(fs[i]) * fs.get_degree(i);
|
||||
}
|
||||
VERIFY(total_degree == 3);
|
||||
|
|
@ -338,7 +338,7 @@ void test_factorization_large_multivariate_missing_factors() {
|
|||
factors fs(m);
|
||||
factor(p, fs);
|
||||
VERIFY(fs.distinct_factors() == 2); // indeed there are 3 factors, that is demonstrated by the loop
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); i++) {
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); ++i) {
|
||||
polynomial_ref f(m);
|
||||
f = fs[i];
|
||||
if (degree(f, x1)<= 1) continue;
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ void tst_prime_generator() {
|
|||
|
||||
prime_generator gen;
|
||||
gen.initialize();
|
||||
for (unsigned i = 0; i < 10000; i++) {
|
||||
for (unsigned i = 0; i < 10000; ++i) {
|
||||
uint64_t p = gen(i);
|
||||
std::cout << p << ", ";
|
||||
if (i % 11 == 0) std::cout << "\n";
|
||||
|
|
@ -36,7 +36,7 @@ void tst_prime_generator() {
|
|||
m.set(sqrt_p, p);
|
||||
m.root(sqrt_p, 2);
|
||||
uint64_t k = m.get_uint64(sqrt_p);
|
||||
for (uint64_t i = 2; i <= k; i++) {
|
||||
for (uint64_t i = 2; i <= k; ++i) {
|
||||
ENSURE(p % i != 0);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ Revision History:
|
|||
static void tst1() {
|
||||
random_gen r(0);
|
||||
TRACE(random,
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
tout << r() << "\n";
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -288,7 +288,7 @@ public:
|
|||
|
||||
static void tst2() {
|
||||
tst_hash(0);
|
||||
for (int i = 0; i <= 10000; i++) {
|
||||
for (int i = 0; i <= 10000; ++i) {
|
||||
int r = rand() % INT_MAX;
|
||||
if (rand()%2 == 1) r = -r;
|
||||
tst_hash(r);
|
||||
|
|
@ -299,7 +299,7 @@ public:
|
|||
static void tst7() {
|
||||
rational p;
|
||||
p = power(rational(2), 32);
|
||||
for (unsigned i = 1; i < 1000; i++) {
|
||||
for (unsigned i = 1; i < 1000; ++i) {
|
||||
rational n(i);
|
||||
rational x;
|
||||
rational y;
|
||||
|
|
@ -396,7 +396,7 @@ static void tst10(bool use_ints) {
|
|||
vals.resize(NUM_RATIONALS);
|
||||
vals2.resize(NUM_RATIONALS);
|
||||
fvals.resize(NUM_RATIONALS);
|
||||
for (unsigned i = 0; i < NUM_RATIONALS; i++) {
|
||||
for (unsigned i = 0; i < NUM_RATIONALS; ++i) {
|
||||
int r1 = rand() % MAGNITUDE;
|
||||
int r2 = use_ints ? 1 : rand() % MAGNITUDE;
|
||||
if (r2 == 0) r2 = 1;
|
||||
|
|
@ -407,13 +407,13 @@ static void tst10(bool use_ints) {
|
|||
}
|
||||
{
|
||||
timeit t(true, "multiplication with rationals");
|
||||
for (unsigned i = 0; i < NUM_RATIONALS - 1; i++) {
|
||||
for (unsigned i = 0; i < NUM_RATIONALS - 1; ++i) {
|
||||
vals[i] *= vals[i+1];
|
||||
}
|
||||
}
|
||||
{
|
||||
timeit t(true, "multiplication with floats: ");
|
||||
for (unsigned i = 0; i < NUM_RATIONALS - 1; i++) {
|
||||
for (unsigned i = 0; i < NUM_RATIONALS - 1; ++i) {
|
||||
fvals[i] *= fvals[i+1];
|
||||
}
|
||||
}
|
||||
|
|
@ -428,7 +428,7 @@ static void tst11(bool use_ints) {
|
|||
vector<float> fvals;
|
||||
vals.resize(NUM_RATIONALS2);
|
||||
fvals.resize(NUM_RATIONALS2);
|
||||
for (unsigned i = 0; i < NUM_RATIONALS2; i++) {
|
||||
for (unsigned i = 0; i < NUM_RATIONALS2; ++i) {
|
||||
int r1 = rand() % MAGNITUDE2;
|
||||
int r2 = use_ints ? 1 : rand() % MAGNITUDE2;
|
||||
if (r2 == 0) r2 = 1;
|
||||
|
|
@ -438,15 +438,15 @@ static void tst11(bool use_ints) {
|
|||
}
|
||||
{
|
||||
timeit t(true, "multiplication with big rationals");
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned i = 0; i < NUM_RATIONALS2-1; i++) {
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
for (unsigned i = 0; i < NUM_RATIONALS2-1; ++i) {
|
||||
vals[i] *= vals[i+1];
|
||||
}
|
||||
}
|
||||
{
|
||||
timeit t(true, "multiplication with floats: ");
|
||||
for (unsigned j = 0; j < 10; j++)
|
||||
for (unsigned i = 0; i < NUM_RATIONALS2-1; i++) {
|
||||
for (unsigned j = 0; j < 10; ++j)
|
||||
for (unsigned i = 0; i < NUM_RATIONALS2-1; ++i) {
|
||||
fvals[i] *= fvals[i+1];
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ static void tst2() {
|
|||
int b[3];
|
||||
int c[3] = { 10, -2, 8 };
|
||||
std::cout << "solve: " << mm.solve(A, b, c) << "\n";
|
||||
for (unsigned i = 0; i < 3; i++) std::cout << b[i] << " ";
|
||||
for (unsigned i = 0; i < 3; ++i) std::cout << b[i] << " ";
|
||||
std::cout << "\n";
|
||||
}
|
||||
scoped_mpz_matrix A2(mm);
|
||||
|
|
@ -111,14 +111,14 @@ static void tst_solve(unsigned n, int _A[], int _b[], int _c[], bool solved) {
|
|||
mpz_matrix_manager mm(nm, allocator);
|
||||
scoped_mpz_matrix A(mm);
|
||||
mm.mk(n, n, A);
|
||||
for (unsigned i = 0; i < n; i++)
|
||||
for (unsigned j = 0; j < n; j++)
|
||||
for (unsigned i = 0; i < n; ++i)
|
||||
for (unsigned j = 0; j < n; ++j)
|
||||
A.set(i, j, _A[i*n + j]);
|
||||
svector<int> b;
|
||||
b.resize(n, 0);
|
||||
if (mm.solve(A, b.data(), _c)) {
|
||||
ENSURE(solved);
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
ENSURE(b[i] == _b[i]);
|
||||
}
|
||||
}
|
||||
|
|
@ -133,14 +133,14 @@ static void tst_lin_indep(unsigned m, unsigned n, int _A[], unsigned ex_sz, unsi
|
|||
mpz_matrix_manager mm(nm, allocator);
|
||||
scoped_mpz_matrix A(mm);
|
||||
mm.mk(m, n, A);
|
||||
for (unsigned i = 0; i < m; i++)
|
||||
for (unsigned j = 0; j < n; j++)
|
||||
for (unsigned i = 0; i < m; ++i)
|
||||
for (unsigned j = 0; j < n; ++j)
|
||||
A.set(i, j, _A[i*n + j]);
|
||||
unsigned_vector r;
|
||||
r.resize(A.n());
|
||||
scoped_mpz_matrix B(mm);
|
||||
mm.linear_independent_rows(A, r.data(), B);
|
||||
for (unsigned i = 0; i < ex_sz; i++) {
|
||||
for (unsigned i = 0; i < ex_sz; ++i) {
|
||||
ENSURE(r[i] == ex_r[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
#include <iostream>
|
||||
|
||||
static void display_model(sat::model const & m) {
|
||||
for (unsigned i = 1; i < m.size(); i++) {
|
||||
for (unsigned i = 1; i < m.size(); ++i) {
|
||||
switch (m[i]) {
|
||||
case l_false: std::cout << "-" << i << " "; break;
|
||||
case l_undef: break;
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ static void tst1() {
|
|||
static void tst2(unsigned num, unsigned del_rate) {
|
||||
ptr_vector<char> ptrs;
|
||||
stack s;
|
||||
for (unsigned i = 0; i < num; i++) {
|
||||
for (unsigned i = 0; i < num; ++i) {
|
||||
ENSURE(ptrs.empty() == s.empty());
|
||||
ENSURE(s.empty() || ptrs.back() == s.top());
|
||||
if (!ptrs.empty() && rand() % del_rate == 0) {
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ static void tst1() {
|
|||
|
||||
static void tst2() {
|
||||
string_buffer<> b;
|
||||
for (unsigned i = 0; i < 10000; i++) {
|
||||
for (unsigned i = 0; i < 10000; ++i) {
|
||||
int r = rand() % 10;
|
||||
b << r;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ static void tst2() {
|
|||
to.insert(1);
|
||||
to.insert_after(1, 2);
|
||||
to.insert_after(2, 3);
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
to.move_after(3, 1);
|
||||
to.move_after(1, 2);
|
||||
to.move_after(2, 3);
|
||||
|
|
@ -52,10 +52,10 @@ static void tst2() {
|
|||
static void tst3(unsigned sz, unsigned num_rounds) {
|
||||
uint_total_order to;
|
||||
to.insert(0);
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
to.insert_after(i, i+1);
|
||||
}
|
||||
for (unsigned i = 0; i < num_rounds; i++) {
|
||||
for (unsigned i = 0; i < num_rounds; ++i) {
|
||||
unsigned v1 = rand() % sz;
|
||||
unsigned v2 = rand() % sz;
|
||||
if (v1 != v2)
|
||||
|
|
@ -78,7 +78,7 @@ void move_after(unsigned_vector & v, unsigned_vector & inv_v, unsigned a, unsign
|
|||
unsigned pos_b = inv_v[b];
|
||||
ENSURE(pos_a != pos_b);
|
||||
if (pos_b < pos_a) {
|
||||
for (unsigned i = pos_b; i < pos_a; i++) {
|
||||
for (unsigned i = pos_b; i < pos_a; ++i) {
|
||||
v[i] = v[i+1];
|
||||
inv_v[v[i+1]] = i;
|
||||
}
|
||||
|
|
@ -106,19 +106,19 @@ static void tst4(unsigned sz, unsigned num_rounds) {
|
|||
to.insert(0);
|
||||
v.push_back(0);
|
||||
inv_v.push_back(0);
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
to.insert_after(i, i+1);
|
||||
v.push_back(i+1);
|
||||
inv_v.push_back(i+1);
|
||||
}
|
||||
for (unsigned i = 0; i < num_rounds; i++) {
|
||||
for (unsigned i = 0; i < num_rounds; ++i) {
|
||||
unsigned v1 = rand() % sz;
|
||||
unsigned v2 = rand() % sz;
|
||||
if (v1 != v2) {
|
||||
to.move_after(v1, v2);
|
||||
move_after(v, inv_v, v1, v2);
|
||||
}
|
||||
for (unsigned k = 0; k < sz - 1; k++) {
|
||||
for (unsigned k = 0; k < sz - 1; ++k) {
|
||||
ENSURE(inv_v[v[k]] == k);
|
||||
ENSURE(to.lt(v[k], v[k+1]));
|
||||
}
|
||||
|
|
@ -133,12 +133,12 @@ static void tst4(unsigned sz, unsigned num_rounds) {
|
|||
static void bad_case(unsigned sz, unsigned num_rounds) {
|
||||
uint_total_order to;
|
||||
to.insert(0);
|
||||
for (unsigned i = 0; i < sz; i++) {
|
||||
for (unsigned i = 0; i < sz; ++i) {
|
||||
to.insert_after(i, i+1);
|
||||
}
|
||||
for (unsigned i = 0; i < num_rounds; i++) {
|
||||
for (unsigned i = 0; i < num_rounds; ++i) {
|
||||
to.move_after(sz, 0);
|
||||
for (unsigned j = 0; j < sz; j++) {
|
||||
for (unsigned j = 0; j < sz; ++j) {
|
||||
to.move_after(j, j+1);
|
||||
}
|
||||
if (i % 10 == 0) {
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ static void tst_sine(std::ostream & out, unsigned N, unsigned k) {
|
|||
scoped_mpq a(nm);
|
||||
nm.set(a, 0);
|
||||
tst_sine_core(out, nm, im, a, 1);
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
nm.set(a, 4 * (rand() % PREC), PREC);
|
||||
if (rand() % 2 == 0)
|
||||
nm.neg(a);
|
||||
|
|
@ -71,7 +71,7 @@ static void tst_cosine(std::ostream & out, unsigned N, unsigned k) {
|
|||
scoped_mpq a(nm);
|
||||
nm.set(a, 0);
|
||||
tst_cosine_core(out, nm, im, a, 1);
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
nm.set(a, 4 * (rand() % PREC), PREC);
|
||||
if (rand() % 2 == 0)
|
||||
nm.neg(a);
|
||||
|
|
@ -111,7 +111,7 @@ static void tst_float_sine(std::ostream & out, unsigned N, unsigned k) {
|
|||
// fm.set(a, EBITS, SBITS, MPF_ROUND_TOWARD_POSITIVE, 25336, 100000);
|
||||
// tst_float_sine_core(out, fm, im, a, k);
|
||||
// return;
|
||||
for (unsigned i = 0; i < N; i++) {
|
||||
for (unsigned i = 0; i < N; ++i) {
|
||||
unsigned n = 4 * (rand() % PREC);
|
||||
unsigned d = PREC;
|
||||
TRACE(sine, tout << "next-val : " << n << "/" << d << "\n";);
|
||||
|
|
@ -140,7 +140,7 @@ static void tst_e(std::ostream & out) {
|
|||
unsynch_mpq_manager nm;
|
||||
interval_manager<im_default_config> im(rl, nm);
|
||||
im_default_config::interval r;
|
||||
for (unsigned i = 0; i < 64; i++) {
|
||||
for (unsigned i = 0; i < 64; ++i) {
|
||||
im.e(i, r);
|
||||
out << nm.to_string(im.lower(r)) << " <= E\n";
|
||||
out << "E <= " << nm.to_string(im.upper(r)) << "\n";
|
||||
|
|
@ -156,7 +156,7 @@ static void tst_e_float(std::ostream & out) {
|
|||
interval_manager<im_float_config<mpf_manager> > im(rl, fm);
|
||||
scoped_mpq q(qm);
|
||||
im_float_config<mpf_manager>::interval r;
|
||||
for (unsigned i = 0; i < 64; i++) {
|
||||
for (unsigned i = 0; i < 64; ++i) {
|
||||
im.e(i, r);
|
||||
out << fm.to_rational_string(im.lower(r)) << " <= E\n";
|
||||
out << "E <= " << fm.to_rational_string(im.upper(r)) << "\n";
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ static void tst1(unsigned n) {
|
|||
unsigned size = 0;
|
||||
|
||||
unsigned num_op = rand()%1000;
|
||||
for (unsigned i = 0; i < num_op; i++) {
|
||||
for (unsigned i = 0; i < num_op; ++i) {
|
||||
unsigned op = rand()%3;
|
||||
if (op < 2) {
|
||||
unsigned idx = rand() % n;
|
||||
|
|
@ -47,7 +47,7 @@ static void tst1(unsigned n) {
|
|||
}
|
||||
ENSURE(s1.num_elems() == size);
|
||||
ENSURE((size == 0) == s1.empty());
|
||||
for (unsigned idx = 0; idx < n; idx++) {
|
||||
for (unsigned idx = 0; idx < n; ++idx) {
|
||||
ENSURE(s2[idx] == s1.contains(idx));
|
||||
}
|
||||
}
|
||||
|
|
@ -60,7 +60,7 @@ static void tst2(unsigned n) {
|
|||
s.insert(val);
|
||||
ENSURE(!s.empty());
|
||||
ENSURE(s.num_elems() == 1);
|
||||
for (unsigned i = 0; i < 100; i++) {
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
unsigned val2 = rand()%n;
|
||||
if (val != val2) {
|
||||
ENSURE(!s.contains(val2));
|
||||
|
|
@ -113,7 +113,7 @@ static void tst3(unsigned n) {
|
|||
ENSURE(s2.subset_of(s4));
|
||||
ENSURE(s4.subset_of(s2));
|
||||
ENSURE(s2 != s3);
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
for (unsigned i = 0; i < n; ++i) {
|
||||
uint_set s5;
|
||||
s5.insert(i);
|
||||
ENSURE(s1.contains(i) == s5.subset_of(s1));
|
||||
|
|
@ -159,11 +159,11 @@ static void tst5() {
|
|||
}
|
||||
|
||||
void tst_uint_set() {
|
||||
for (unsigned i = 0; i < 100; i++) {
|
||||
for (unsigned i = 0; i < 100; ++i) {
|
||||
tst1(1 + rand()%31);
|
||||
tst1(1 + rand()%100);
|
||||
}
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
tst2(1);
|
||||
tst2(10);
|
||||
tst2(31);
|
||||
|
|
|
|||
|
|
@ -41,12 +41,12 @@ static void tst1() {
|
|||
|
||||
// display coefficients of q
|
||||
std::cout << "expanded q: ";
|
||||
for (unsigned i = 0; i < q.size(); i++)
|
||||
for (unsigned i = 0; i < q.size(); ++i)
|
||||
std::cout << nm.to_string(q[i]) << " ";
|
||||
std::cout << "\n";
|
||||
|
||||
// traverse coefficients of q adding 1
|
||||
for (unsigned i = 0; i < q.size(); i++) {
|
||||
for (unsigned i = 0; i < q.size(); ++i) {
|
||||
nm.add(q[i], mpz(1), q[i]);
|
||||
}
|
||||
// All operations in upolynomial::manager assume the leading coefficient of q is not zero.
|
||||
|
|
@ -104,7 +104,7 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
std::cout << "sign var(+oo): " << um.sign_variations_at_plus_inf(sseq) << "\n";
|
||||
ENSURE(roots.size() + lowers.size() == um.sign_variations_at_minus_inf(sseq) - um.sign_variations_at_plus_inf(sseq));
|
||||
std::cout << "roots:";
|
||||
for (unsigned i = 0; i < roots.size(); i++) {
|
||||
for (unsigned i = 0; i < roots.size(); ++i) {
|
||||
ENSURE(um.eval_sign_at(q.size(), q.data(), roots[i]) == 0);
|
||||
std::cout << " "; bqm.display_decimal(std::cout, roots[i], prec);
|
||||
}
|
||||
|
|
@ -112,7 +112,7 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
timeit timer(true, "interval check");
|
||||
std::cout << "\n";
|
||||
std::cout << "intervals:";
|
||||
for (unsigned i = 0; i < lowers.size(); i++) {
|
||||
for (unsigned i = 0; i < lowers.size(); ++i) {
|
||||
std::cout << " (";
|
||||
bqm.display_decimal(std::cout, lowers[i], prec);
|
||||
std::cout << ", ";
|
||||
|
|
@ -159,10 +159,10 @@ static void check_roots(mpbq_vector const & roots, mpbq_vector const & lowers, m
|
|||
ENSURE(expected_sz == roots.size() + lowers.size());
|
||||
bool_vector visited;
|
||||
visited.resize(expected_sz, false);
|
||||
for (unsigned i = 0; i < expected_sz; i++) {
|
||||
for (unsigned i = 0; i < expected_sz; ++i) {
|
||||
rational const & r = expected_roots[i];
|
||||
bool found = false;
|
||||
for (unsigned j = 0; j < roots.size(); j++) {
|
||||
for (unsigned j = 0; j < roots.size(); ++j) {
|
||||
if (to_rational(roots[j]) == r) {
|
||||
ENSURE(!visited[j]);
|
||||
VERIFY(!found);
|
||||
|
|
@ -170,7 +170,7 @@ static void check_roots(mpbq_vector const & roots, mpbq_vector const & lowers, m
|
|||
visited[j] = true;
|
||||
}
|
||||
}
|
||||
for (unsigned j = 0; j < lowers.size(); j++) {
|
||||
for (unsigned j = 0; j < lowers.size(); ++j) {
|
||||
unsigned j_prime = j + roots.size();
|
||||
if (to_rational(lowers[j]) < r && r < to_rational(uppers[j])) {
|
||||
VERIFY(!found);
|
||||
|
|
@ -889,7 +889,7 @@ static void tst_fact(polynomial_ref const & p, unsigned num_distinct_factors, up
|
|||
um.factor(_p, fs, params);
|
||||
std::cout << "factors:\n";
|
||||
std::cout << um.m().to_string(fs.get_constant()) << "\n";
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); i++) {
|
||||
for (unsigned i = 0; i < fs.distinct_factors(); ++i) {
|
||||
std::cout << "*("; um.display(std::cout, fs[i]); std::cout << ")^" << fs.get_degree(i) << std::endl;
|
||||
}
|
||||
std::cout << fs.distinct_factors() << " " << num_distinct_factors << "\n";
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ void tst_instantiate(ast_manager & m, expr * f) {
|
|||
quantifier * q = find_quantifier(f);
|
||||
if (q) {
|
||||
expr_ref_vector cnsts(m);
|
||||
for (unsigned i = 0; i < q->get_num_decls(); i++)
|
||||
for (unsigned i = 0; i < q->get_num_decls(); ++i)
|
||||
cnsts.push_back(m.mk_fresh_const("a", q->get_decl_sort(i)));
|
||||
expr_ref r = instantiate(m, q, cnsts.data());
|
||||
TRACE(var_subst, tout << "quantifier:\n" << mk_pp(q, m) << "\nresult:\n" << mk_pp(r, m) << "\n";);
|
||||
|
|
|
|||
|
|
@ -22,13 +22,13 @@ Revision History:
|
|||
static void tst1() {
|
||||
svector<int> v1;
|
||||
ENSURE(v1.empty());
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
v1.push_back(i + 3);
|
||||
ENSURE(static_cast<unsigned>(v1[i]) == i + 3);
|
||||
ENSURE(v1.capacity() >= v1.size());
|
||||
ENSURE(!v1.empty());
|
||||
}
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
ENSURE(static_cast<unsigned>(v1[i]) == i + 3);
|
||||
}
|
||||
svector<int>::iterator it = v1.begin();
|
||||
|
|
@ -36,7 +36,7 @@ static void tst1() {
|
|||
for (int i = 0; it != end; ++it, ++i) {
|
||||
ENSURE(*it == i + 3);
|
||||
}
|
||||
for (unsigned i = 0; i < 1000; i++) {
|
||||
for (unsigned i = 0; i < 1000; ++i) {
|
||||
ENSURE(static_cast<unsigned>(v1.back()) == 1000 - i - 1 + 3);
|
||||
ENSURE(v1.size() == 1000 - i);
|
||||
v1.pop_back();
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ static void tst_ascii_roundtrip() {
|
|||
unsigned ascii_min = 0x20; // ' '
|
||||
unsigned ascii_max = 0x7E; // '~'
|
||||
|
||||
for (unsigned i = ascii_min; i <= ascii_max; i++) {
|
||||
for (unsigned i = ascii_min; i <= ascii_max; ++i) {
|
||||
zstring input(i);
|
||||
std::string expected(1, i);
|
||||
bool roundtrip_ok = input.encode() == expected;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue