mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 17:15:31 +00:00
call it data instead of c_ptr for approaching C++11 std::vector convention.
This commit is contained in:
Nikolaj Bjorner
parent
524dcd35f9
commit
4a6083836a
456 changed files with 2802 additions and 2802 deletions
|
|
@ -26,8 +26,8 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
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.c_ptr());
|
||||
ENSURE(!has_one_at_first_k_bits(sz, actual_dst.c_ptr(), k));
|
||||
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++) {
|
||||
if (trace && dst[i] != actual_dst[i])
|
||||
std::cout << "UNEXPECTED RESULT at [" << i << "]: " << actual_dst[i] << ", expected: " << dst[i] << "\n";
|
||||
|
|
@ -36,7 +36,7 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
if (sz == src_sz) {
|
||||
unsigned nz1 = nlz(sz, src);
|
||||
if (nz1 >= k && !is_zero(sz, src)) {
|
||||
unsigned nz2 = nlz(sz, actual_dst.c_ptr());
|
||||
unsigned nz2 = nlz(sz, actual_dst.data());
|
||||
if (nz1 - k != nz2) {
|
||||
if (trace)
|
||||
std::cout << "nlz BUG, nlz1: " << nz1 << ", k: " << k << ", nlz2: " << nz2 << std::endl;
|
||||
|
|
@ -47,7 +47,7 @@ static void tst_shl(unsigned src_sz, unsigned const * src, unsigned k,
|
|||
if (sz >= src_sz + (k/32) + 1) {
|
||||
svector<unsigned> new_src;
|
||||
new_src.resize(sz, 0xAAAAAAAA);
|
||||
shr(sz, actual_dst.c_ptr(), k, new_src.c_ptr());
|
||||
shr(sz, actual_dst.data(), k, new_src.data());
|
||||
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;
|
||||
|
|
@ -58,9 +58,9 @@ 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.c_ptr());
|
||||
copy(src_sz, src, dst_sz, actual_dst.data());
|
||||
for (unsigned i = 0; i < k; i++) {
|
||||
shl(dst_sz, actual_dst.c_ptr(), 1, dst_sz, actual_dst.c_ptr());
|
||||
shl(dst_sz, actual_dst.data(), 1, dst_sz, actual_dst.data());
|
||||
}
|
||||
for (unsigned i = 0; i < dst_sz; i++) {
|
||||
if (trace && dst[i] != actual_dst[i])
|
||||
|
|
@ -130,7 +130,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.c_ptr());
|
||||
shr(src_sz, src, k, actual_dst.data());
|
||||
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";
|
||||
|
|
@ -182,7 +182,7 @@ static void tst_shl_rand(unsynch_mpz_manager & m, unsigned sz, unsigned k, bool
|
|||
unsigned word_shift = (k / 32);
|
||||
for (unsigned i = 0; i < word_shift; i++)
|
||||
dst.push_back(0);
|
||||
tst_shl(src.size(), src.c_ptr(), k, dst.size(), dst.c_ptr(), trace);
|
||||
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) {
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ static void track_clause(sat::solver& dst,
|
|||
sat::literal lit = sat::literal(dst.mk_var(true, false), false);
|
||||
tracking_clauses.set(lit.var(), lits);
|
||||
lits.push_back(~lit);
|
||||
dst.mk_clause(lits.size(), lits.c_ptr());
|
||||
dst.mk_clause(lits.size(), lits.data());
|
||||
assumptions.push_back(lit);
|
||||
}
|
||||
|
||||
|
|
@ -145,7 +145,7 @@ static void brute_force_consequences(sat::solver& s, sat::literal_vector const&
|
|||
sat::literal nlit = ~gamma[i];
|
||||
sat::literal_vector asms1(asms);
|
||||
asms1.push_back(nlit);
|
||||
lbool r = s.check(asms1.size(), asms1.c_ptr());
|
||||
lbool r = s.check(asms1.size(), asms1.data());
|
||||
if (r == l_false) {
|
||||
backbones.push_back(gamma[i]);
|
||||
}
|
||||
|
|
@ -153,7 +153,7 @@ static void brute_force_consequences(sat::solver& s, sat::literal_vector const&
|
|||
}
|
||||
|
||||
static lbool core_chunking(sat::solver& s, sat::bool_var_vector& vars, sat::literal_vector const& asms, vector<sat::literal_vector>& conseq, unsigned K) {
|
||||
lbool r = s.check(asms.size(), asms.c_ptr());
|
||||
lbool r = s.check(asms.size(), asms.data());
|
||||
if (r != l_true) {
|
||||
return r;
|
||||
}
|
||||
|
|
@ -174,7 +174,7 @@ static lbool core_chunking(sat::solver& s, sat::bool_var_vector& vars, sat::lite
|
|||
while (true) {
|
||||
sat::literal_vector asms1(asms);
|
||||
asms1.append(omegaN);
|
||||
r = s.check(asms1.size(), asms1.c_ptr());
|
||||
r = s.check(asms1.size(), asms1.data());
|
||||
if (r == l_true) {
|
||||
IF_VERBOSE(1, verbose_stream() << "(sat) " << omegaN << "\n";);
|
||||
prune_unfixed(lambda, s.get_model());
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ Copyright (c) 2015 Microsoft Corporation
|
|||
using namespace datalog;
|
||||
|
||||
void dl_query_ask_ground_query(context & ctx, func_decl * pred, relation_fact & f, bool should_be_successful) {
|
||||
expr * const * q_args = reinterpret_cast<expr * const *>(f.c_ptr());
|
||||
expr * const * q_args = reinterpret_cast<expr * const *>(f.data());
|
||||
app * query = ctx.get_manager().mk_app(pred, q_args);
|
||||
|
||||
lbool is_sat = ctx.query(query);
|
||||
|
|
@ -36,7 +36,7 @@ void dl_query_ask_for_last_arg(context & ctx, func_decl * pred, relation_fact &
|
|||
push_into_vector(query_args, f);
|
||||
query_args.pop_back();
|
||||
query_args.push_back(m.mk_var(0, pred->get_domain(query_args.size())));
|
||||
app * query = ctx.get_manager().mk_app(pred, query_args.c_ptr());
|
||||
app * query = ctx.get_manager().mk_app(pred, query_args.data());
|
||||
|
||||
lbool is_sat = ctx.query(query);
|
||||
std::cerr << "@@ last arg query should succeed: " << should_be_successful << "\n";
|
||||
|
|
@ -178,7 +178,7 @@ void dl_query_test_wpa(smt_params & fparams, params_ref& params) {
|
|||
q_args.push_back(dl_util.mk_numeral(el1, var_sort));
|
||||
q_args.push_back(dl_util.mk_numeral(el2, var_sort));
|
||||
|
||||
app_ref query_lit(m.mk_app(v_pred, q_args.c_ptr()), m);
|
||||
app_ref query_lit(m.mk_app(v_pred, q_args.data()), m);
|
||||
lbool is_sat = ctx.query(query_lit);
|
||||
ENSURE(is_sat != l_undef);
|
||||
bool found = is_sat == l_true;
|
||||
|
|
@ -190,7 +190,7 @@ void dl_query_test_wpa(smt_params & fparams, params_ref& params) {
|
|||
q_args.pop_back();
|
||||
q_args.push_back(m.mk_var(0, var_sort));
|
||||
|
||||
query_lit = m.mk_app(v_pred, q_args.c_ptr());
|
||||
query_lit = m.mk_app(v_pred, q_args.data());
|
||||
is_sat = ctx.query(query_lit.get());
|
||||
ENSURE(is_sat != l_false);
|
||||
std::cerr<<"non-ground query finished\n";
|
||||
|
|
|
|||
|
|
@ -173,7 +173,7 @@ class test_doc_cls {
|
|||
default: break;
|
||||
}
|
||||
}
|
||||
result = mk_and(m, conjs.size(), conjs.c_ptr());
|
||||
result = mk_and(m, conjs.size(), conjs.data());
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -197,7 +197,7 @@ class test_doc_cls {
|
|||
break;
|
||||
}
|
||||
}
|
||||
result = mk_and(m, conjs.size(), conjs.c_ptr());
|
||||
result = mk_and(m, conjs.size(), conjs.data());
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -208,7 +208,7 @@ class test_doc_cls {
|
|||
for (unsigned i = 0; i < d.neg().size(); ++i) {
|
||||
conjs.push_back(m.mk_not(to_formula(d.neg()[i], m2)));
|
||||
}
|
||||
result = mk_and(m, conjs.size(), conjs.c_ptr());
|
||||
result = mk_and(m, conjs.size(), conjs.data());
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -218,7 +218,7 @@ class test_doc_cls {
|
|||
for (unsigned i = 0; i < ud.size(); ++i) {
|
||||
disjs.push_back(to_formula(ud[i], m2));
|
||||
}
|
||||
result = mk_or(m, disjs.size(), disjs.c_ptr());
|
||||
result = mk_or(m, disjs.size(), disjs.data());
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -299,7 +299,7 @@ class test_doc_cls {
|
|||
fmls.push_back(m.mk_not(mk_conj(*t)));
|
||||
d->neg().push_back(t);
|
||||
}
|
||||
fml1 = mk_and(m, fmls.size(), fmls.c_ptr());
|
||||
fml1 = mk_and(m, fmls.size(), fmls.data());
|
||||
bool_vector to_merge(N, false);
|
||||
bit_vector discard_cols;
|
||||
discard_cols.resize(N, false);
|
||||
|
|
@ -321,7 +321,7 @@ class test_doc_cls {
|
|||
}
|
||||
}
|
||||
eqs.push_back(to_formula(*d, dm));
|
||||
fml1 = mk_and(m, eqs.size(), eqs.c_ptr());
|
||||
fml1 = mk_and(m, eqs.size(), eqs.data());
|
||||
if (dm.merge(*d, lo, 1, equalities, discard_cols)) {
|
||||
fml2 = to_formula(*d, dm);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ void expr_delta::assert_cnstr(expr* n) {
|
|||
}
|
||||
|
||||
bool expr_delta::delta_dfs(unsigned n, expr_ref_vector& result) {
|
||||
return delta_dfs(n, m_exprs.size(), m_exprs.c_ptr(), result);
|
||||
return delta_dfs(n, m_exprs.size(), m_exprs.data(), result);
|
||||
}
|
||||
|
||||
bool expr_delta::delta_dfs(unsigned& n, unsigned sz, expr* const* exprs, expr_ref_vector& result) {
|
||||
|
|
@ -38,7 +38,7 @@ bool expr_delta::delta_dfs(unsigned& n, unsigned sz, expr* const* exprs, expr_re
|
|||
bool expr_delta::delta_dfs(unsigned& n, app* a, expr_ref& result) {
|
||||
expr_ref_vector args(m_manager);
|
||||
if (delta_dfs(n, a->get_num_args(), a->get_args(), args)) {
|
||||
result = m_manager.mk_app(a->get_decl(), args.size(), args.c_ptr());
|
||||
result = m_manager.mk_app(a->get_decl(), args.size(), args.data());
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ void expr_rand::walk() {
|
|||
for (unsigned i = 0; i < arity; ++i) {
|
||||
args.push_back(choose_expr(f->get_domain(i)));
|
||||
}
|
||||
expr* r = m_manager.mk_app(f, args.size(), args.c_ptr());
|
||||
expr* r = m_manager.mk_app(f, args.size(), args.data());
|
||||
add_expr(r);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -160,15 +160,15 @@ expr_ref hilbert_basis_validate::mk_validate(hilbert_basis& hb) {
|
|||
for (unsigned k = 0; k < increments.size(); ++k) {
|
||||
sum.push_back(increments[k][j].get());
|
||||
}
|
||||
eqs.push_back(m.mk_eq(xs[j].get(), a.mk_add(sum.size(), sum.c_ptr())));
|
||||
eqs.push_back(m.mk_eq(xs[j].get(), a.mk_add(sum.size(), sum.data())));
|
||||
}
|
||||
fml = m.mk_and(eqs.size(), eqs.c_ptr());
|
||||
fml = m.mk_and(eqs.size(), eqs.data());
|
||||
if (!names.empty()) {
|
||||
fml = m.mk_exists(names.size(), sorts.c_ptr(), names.c_ptr(), fml);
|
||||
fml = m.mk_exists(names.size(), sorts.data(), names.data(), fml);
|
||||
}
|
||||
fmls.push_back(fml);
|
||||
}
|
||||
fml1 = m.mk_or(fmls.size(), fmls.c_ptr());
|
||||
fml1 = m.mk_or(fmls.size(), fmls.data());
|
||||
fmls.reset();
|
||||
|
||||
sz = hb.get_num_ineqs();
|
||||
|
|
@ -184,7 +184,7 @@ expr_ref hilbert_basis_validate::mk_validate(hilbert_basis& hb) {
|
|||
}
|
||||
}
|
||||
expr_ref lhs(m), rhs(m);
|
||||
lhs = a.mk_add(sum.size(), sum.c_ptr());
|
||||
lhs = a.mk_add(sum.size(), sum.data());
|
||||
rhs = a.mk_numeral(bound, true);
|
||||
if (is_eq) {
|
||||
fmls.push_back(a.mk_eq(lhs, rhs));
|
||||
|
|
@ -193,7 +193,7 @@ expr_ref hilbert_basis_validate::mk_validate(hilbert_basis& hb) {
|
|||
fmls.push_back(a.mk_ge(lhs, rhs));
|
||||
}
|
||||
}
|
||||
fml2 = m.mk_and(fmls.size(), fmls.c_ptr());
|
||||
fml2 = m.mk_and(fmls.size(), fmls.data());
|
||||
fml = m.mk_eq(fml1, fml2);
|
||||
|
||||
bounds.reset();
|
||||
|
|
@ -203,7 +203,7 @@ expr_ref hilbert_basis_validate::mk_validate(hilbert_basis& hb) {
|
|||
}
|
||||
}
|
||||
if (!bounds.empty()) {
|
||||
fml = m.mk_implies(m.mk_and(bounds.size(), bounds.c_ptr()), fml);
|
||||
fml = m.mk_implies(m.mk_and(bounds.size(), bounds.data()), fml);
|
||||
}
|
||||
return fml;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,9 +21,9 @@ void tst_horn_subsume_model_converter() {
|
|||
ints.push_back(a.mk_int());
|
||||
|
||||
func_decl_ref p(m), q(m), r(m);
|
||||
p = m.mk_func_decl(symbol("p"), 2, ints.c_ptr(), m.mk_bool_sort());
|
||||
q = m.mk_func_decl(symbol("q"), 2, ints.c_ptr(), m.mk_bool_sort());
|
||||
r = m.mk_func_decl(symbol("r"), 2, ints.c_ptr(), m.mk_bool_sort());
|
||||
p = m.mk_func_decl(symbol("p"), 2, ints.data(), m.mk_bool_sort());
|
||||
q = m.mk_func_decl(symbol("q"), 2, ints.data(), m.mk_bool_sort());
|
||||
r = m.mk_func_decl(symbol("r"), 2, ints.data(), m.mk_bool_sort());
|
||||
|
||||
ref<horn_subsume_model_converter> mc = alloc(horn_subsume_model_converter,m);
|
||||
model_ref mr = alloc(model, m);
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ namespace karr {
|
|||
TD.display(std::cout << "TD:\n");
|
||||
for (unsigned i = 0; i < TD.size(); ++i) {
|
||||
vector<rational> v;
|
||||
v.append(src.size(), TD.A[i].c_ptr() + src.size());
|
||||
v.append(src.size(), TD.A[i].data() + src.size());
|
||||
dst.A.push_back(v);
|
||||
dst.b.push_back(TD.b[i]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,8 +21,8 @@ void tst_model2expr() {
|
|||
ints.push_back(a.mk_int());
|
||||
|
||||
func_decl_ref p(m), q(m), x(m);
|
||||
p = m.mk_func_decl(symbol("p"), 2, ints.c_ptr(), a.mk_int());
|
||||
q = m.mk_func_decl(symbol("q"), 2, ints.c_ptr(), a.mk_int());
|
||||
p = m.mk_func_decl(symbol("p"), 2, ints.data(), a.mk_int());
|
||||
q = m.mk_func_decl(symbol("q"), 2, ints.data(), a.mk_int());
|
||||
x = m.mk_const_decl(symbol("x"), a.mk_int());
|
||||
expr_ref n0(m), n1(m), n2(m);
|
||||
n0 = a.mk_numeral(rational(0), true);
|
||||
|
|
@ -35,12 +35,12 @@ void tst_model2expr() {
|
|||
expr_ref_vector args(m);
|
||||
args.push_back(n1);
|
||||
args.push_back(n2);
|
||||
fip->insert_entry(args.c_ptr(), n1);
|
||||
fiq->insert_entry(args.c_ptr(), n1);
|
||||
fip->insert_entry(args.data(), n1);
|
||||
fiq->insert_entry(args.data(), n1);
|
||||
args[0] = n0;
|
||||
args[1] = n1;
|
||||
fip->insert_entry(args.c_ptr(), n2);
|
||||
fiq->insert_entry(args.c_ptr(), n2);
|
||||
fip->insert_entry(args.data(), n2);
|
||||
fiq->insert_entry(args.data(), n2);
|
||||
|
||||
fip->set_else(n0);
|
||||
|
||||
|
|
|
|||
|
|
@ -311,7 +311,7 @@ static void project(nlsat::solver& s, nlsat::explain& ex, nlsat::var x, unsigned
|
|||
s.display(std::cout, num, lits);
|
||||
nlsat::scoped_literal_vector result(s);
|
||||
ex.project(x, num, lits, result);
|
||||
s.display(std::cout << "\n==>\n", result.size(), result.c_ptr());
|
||||
s.display(std::cout << "\n==>\n", result.size(), result.data());
|
||||
std::cout << "\n";
|
||||
}
|
||||
|
||||
|
|
@ -398,12 +398,12 @@ static void tst6() {
|
|||
s.set_rvalues(as);
|
||||
|
||||
|
||||
project(s, ex, x0, 2, lits.c_ptr());
|
||||
project(s, ex, x1, 3, lits.c_ptr());
|
||||
project(s, ex, x2, 3, lits.c_ptr());
|
||||
project(s, ex, x2, 2, lits.c_ptr());
|
||||
project(s, ex, x2, 4, lits.c_ptr());
|
||||
project(s, ex, x2, 3, lits.c_ptr()+1);
|
||||
project(s, ex, x0, 2, lits.data());
|
||||
project(s, ex, x1, 3, lits.data());
|
||||
project(s, ex, x2, 3, lits.data());
|
||||
project(s, ex, x2, 2, lits.data());
|
||||
project(s, ex, x2, 4, lits.data());
|
||||
project(s, ex, x2, 3, lits.data()+1);
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -441,7 +441,7 @@ static void tst7() {
|
|||
lits.push_back(mk_gt(s, p2));
|
||||
lits.push_back(mk_gt(s, p3));
|
||||
|
||||
nlsat::literal_vector litsv(lits.size(), lits.c_ptr());
|
||||
nlsat::literal_vector litsv(lits.size(), lits.data());
|
||||
lbool res = s.check(litsv);
|
||||
VERIFY(res == l_false);
|
||||
for (unsigned i = 0; i < litsv.size(); ++i) {
|
||||
|
|
@ -451,7 +451,7 @@ static void tst7() {
|
|||
std::cout << "\n";
|
||||
|
||||
litsv.reset();
|
||||
litsv.append(2, lits.c_ptr());
|
||||
litsv.append(2, lits.data());
|
||||
res = s.check(litsv);
|
||||
ENSURE(res == l_true);
|
||||
s.display(std::cout);
|
||||
|
|
@ -505,7 +505,7 @@ static void tst8() {
|
|||
|
||||
nlsat::scoped_literal_vector lits(s);
|
||||
lits.push_back(mk_eq(s, (_a*_x2*_x2) - (_b*_x2) - _c));
|
||||
project(s, ex, x2, 1, lits.c_ptr());
|
||||
project(s, ex, x2, 1, lits.data());
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -560,16 +560,16 @@ static void tst9() {
|
|||
#define TEST_ON_OFF() \
|
||||
std::cout << "Off "; \
|
||||
ex.set_signed_project(false); \
|
||||
project(s, ex, _x, lits.size()-1, lits.c_ptr()); \
|
||||
project(s, ex, _x, lits.size()-1, lits.data()); \
|
||||
std::cout << "On "; \
|
||||
ex.set_signed_project(true); \
|
||||
project(s, ex, _x, lits.size()-1, lits.c_ptr()); \
|
||||
project(s, ex, _x, lits.size()-1, lits.data()); \
|
||||
std::cout << "Off "; \
|
||||
ex.set_signed_project(false); \
|
||||
project(s, ex, _x, lits.size(), lits.c_ptr()); \
|
||||
project(s, ex, _x, lits.size(), lits.data()); \
|
||||
std::cout << "On "; \
|
||||
ex.set_signed_project(true); \
|
||||
project(s, ex, _x, lits.size(), lits.c_ptr()) \
|
||||
project(s, ex, _x, lits.size(), lits.data()) \
|
||||
|
||||
TEST_ON_OFF();
|
||||
|
||||
|
|
@ -620,7 +620,7 @@ static void test_root_literal(nlsat::solver& s, nlsat::explain& ex, nlsat::var x
|
|||
ex.test_root_literal(k, x, 1, p, result);
|
||||
nlsat::bool_var b = s.mk_root_atom(k, x, i, p);
|
||||
s.display(std::cout, nlsat::literal(b, false));
|
||||
s.display(std::cout << " ==> ", result.size(), result.c_ptr());
|
||||
s.display(std::cout << " ==> ", result.size(), result.data());
|
||||
std::cout << "\n";
|
||||
}
|
||||
|
||||
|
|
@ -748,7 +748,7 @@ static void tst11() {
|
|||
lits.reset();
|
||||
lits.push_back(mk_gt(s, p1));
|
||||
lits.push_back(mk_eq(s, p2));
|
||||
project_fa(s, ex, x, 2, lits.c_ptr());
|
||||
project_fa(s, ex, x, 2, lits.data());
|
||||
// return;
|
||||
|
||||
p1 = ((_x * _x) - (2 * _y * _x) - _z + (_y *_y));
|
||||
|
|
@ -759,7 +759,7 @@ static void tst11() {
|
|||
lits.reset();
|
||||
lits.push_back(mk_lt(s, p1));
|
||||
lits.push_back(mk_eq(s, p2));
|
||||
project_fa(s, ex, x, 2, lits.c_ptr());
|
||||
project_fa(s, ex, x, 2, lits.data());
|
||||
return;
|
||||
|
||||
as.set(z, zero);
|
||||
|
|
@ -770,7 +770,7 @@ static void tst11() {
|
|||
lits.reset();
|
||||
lits.push_back(mk_gt(s, p1));
|
||||
lits.push_back(mk_eq(s, p2));
|
||||
project_fa(s, ex, x, 2, lits.c_ptr());
|
||||
project_fa(s, ex, x, 2, lits.data());
|
||||
|
||||
#if 0
|
||||
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ static void test1() {
|
|||
for (unsigned k = 1; k <= N; ++k) {
|
||||
expr_ref fml(m), result(m);
|
||||
proof_ref proof(m);
|
||||
fml = pb.mk_at_least_k(vars.size(), vars.c_ptr(), k);
|
||||
fml = pb.mk_at_least_k(vars.size(), vars.data(), k);
|
||||
rw(true, fml, result, proof);
|
||||
std::cout << fml << " |-> " << result << "\n";
|
||||
}
|
||||
|
|
@ -57,9 +57,9 @@ static void test_semantics(ast_manager& m, expr_ref_vector const& vars, vector<r
|
|||
th_rewriter th_rw(m);
|
||||
|
||||
switch (kind) {
|
||||
case 0: fml1 = pb.mk_ge(vars.size(), coeffs.c_ptr(), vars.c_ptr(), rational(k)); break;
|
||||
case 1: fml1 = pb.mk_le(vars.size(), coeffs.c_ptr(), vars.c_ptr(), rational(k)); break;
|
||||
default: fml1 = pb.mk_eq(vars.size(), coeffs.c_ptr(), vars.c_ptr(), rational(k)); break;
|
||||
case 0: fml1 = pb.mk_ge(vars.size(), coeffs.data(), vars.data(), rational(k)); break;
|
||||
case 1: fml1 = pb.mk_le(vars.size(), coeffs.data(), vars.data(), rational(k)); break;
|
||||
default: fml1 = pb.mk_eq(vars.size(), coeffs.data(), vars.data(), rational(k)); break;
|
||||
}
|
||||
rw(true, fml1, result1, proof);
|
||||
rw.flush_side_constraints(lemmas);
|
||||
|
|
@ -77,9 +77,9 @@ static void test_semantics(ast_manager& m, expr_ref_vector const& vars, vector<r
|
|||
|
||||
solver.assert_expr(lemmas);
|
||||
switch (kind) {
|
||||
case 0: fml2 = pb.mk_ge(tf.size(), coeffs.c_ptr(), tf.c_ptr(), rational(k)); break;
|
||||
case 1: fml2 = pb.mk_le(tf.size(), coeffs.c_ptr(), tf.c_ptr(), rational(k)); break;
|
||||
default: fml2 = pb.mk_eq(tf.size(), coeffs.c_ptr(), tf.c_ptr(), rational(k)); break;
|
||||
case 0: fml2 = pb.mk_ge(tf.size(), coeffs.data(), tf.data(), rational(k)); break;
|
||||
case 1: fml2 = pb.mk_le(tf.size(), coeffs.data(), tf.data(), rational(k)); break;
|
||||
default: fml2 = pb.mk_eq(tf.size(), coeffs.data(), tf.data(), rational(k)); break;
|
||||
}
|
||||
std::cout << fml1 << " " << fml2 << "\n";
|
||||
th_rw(fml2, result2, proof);
|
||||
|
|
@ -136,9 +136,9 @@ static void test_solver_semantics(ast_manager& m, expr_ref_vector const& vars, v
|
|||
th_rewriter th_rw(m);
|
||||
|
||||
switch (kind) {
|
||||
case 0: fml1 = pb.mk_ge(vars.size(), coeffs.c_ptr(), vars.c_ptr(), rational(k)); break;
|
||||
case 1: fml1 = pb.mk_le(vars.size(), coeffs.c_ptr(), vars.c_ptr(), rational(k)); break;
|
||||
default: fml1 = pb.mk_eq(vars.size(), coeffs.c_ptr(), vars.c_ptr(), rational(k)); break;
|
||||
case 0: fml1 = pb.mk_ge(vars.size(), coeffs.data(), vars.data(), rational(k)); break;
|
||||
case 1: fml1 = pb.mk_le(vars.size(), coeffs.data(), vars.data(), rational(k)); break;
|
||||
default: fml1 = pb.mk_eq(vars.size(), coeffs.data(), vars.data(), rational(k)); break;
|
||||
}
|
||||
result1 = m.mk_fresh_const("xx", m.mk_bool_sort());
|
||||
for (unsigned values = 0; values < static_cast<unsigned>(1 << N); ++values) {
|
||||
|
|
@ -152,9 +152,9 @@ static void test_solver_semantics(ast_manager& m, expr_ref_vector const& vars, v
|
|||
slv->assert_expr(m.mk_eq(result1, fml1));
|
||||
|
||||
switch (kind) {
|
||||
case 0: fml2 = pb.mk_ge(tf.size(), coeffs.c_ptr(), tf.c_ptr(), rational(k)); break;
|
||||
case 1: fml2 = pb.mk_le(tf.size(), coeffs.c_ptr(), tf.c_ptr(), rational(k)); break;
|
||||
default: fml2 = pb.mk_eq(tf.size(), coeffs.c_ptr(), tf.c_ptr(), rational(k)); break;
|
||||
case 0: fml2 = pb.mk_ge(tf.size(), coeffs.data(), tf.data(), rational(k)); break;
|
||||
case 1: fml2 = pb.mk_le(tf.size(), coeffs.data(), tf.data(), rational(k)); break;
|
||||
default: fml2 = pb.mk_eq(tf.size(), coeffs.data(), tf.data(), rational(k)); break;
|
||||
}
|
||||
std::cout << fml1 << " " << fml2 << "\n";
|
||||
th_rw(fml2, result2, proof);
|
||||
|
|
|
|||
|
|
@ -111,10 +111,10 @@ namespace dd {
|
|||
for (unsigned i = 0; i < args.size(); ++i) {
|
||||
args[i] = mk_not(m, args.get(i));
|
||||
}
|
||||
g = m.mk_not(m.mk_and(args.size(), args.c_ptr()));
|
||||
g = m.mk_not(m.mk_and(args.size(), args.data()));
|
||||
}
|
||||
else if (m.is_and(a)) {
|
||||
g = m.mk_and(args.size(), args.c_ptr());
|
||||
g = m.mk_and(args.size(), args.data());
|
||||
trail.push_back(g);
|
||||
}
|
||||
else if (m.is_eq(a)) {
|
||||
|
|
@ -134,7 +134,7 @@ namespace dd {
|
|||
g = mk_not(m, args.get(0));
|
||||
}
|
||||
else {
|
||||
g = m.mk_app(a->get_decl(), args.size(), args.c_ptr());
|
||||
g = m.mk_app(a->get_decl(), args.size(), args.data());
|
||||
}
|
||||
trail.push_back(g);
|
||||
cache.insert(a, g);
|
||||
|
|
|
|||
|
|
@ -928,7 +928,7 @@ static void tst_substitute(polynomial_ref const & p,
|
|||
std::cout << "---------------\n";
|
||||
std::cout << "p: " << p << std::endl;
|
||||
polynomial_ref r(p.m());
|
||||
r = p.m().substitute(p, 2, xs, vs.c_ptr());
|
||||
r = p.m().substitute(p, 2, xs, vs.data());
|
||||
std::cout << "r: " << r << std::endl;
|
||||
std::cout << "expected: " << expected << std::endl;
|
||||
ENSURE(eq(r, expected));
|
||||
|
|
@ -969,7 +969,7 @@ static void tst_qsubstitute(polynomial_ref const & p,
|
|||
std::cout << "---------------\n";
|
||||
std::cout << "p: " << p << std::endl;
|
||||
polynomial_ref r(p.m());
|
||||
r = p.m().substitute(p, 2, xs, vs.c_ptr());
|
||||
r = p.m().substitute(p, 2, xs, vs.data());
|
||||
std::cout << "r: " << r << std::endl;
|
||||
std::cout << "expected (modulo a constant): " << expected << std::endl;
|
||||
ENSURE(eq(r, normalize(expected)));
|
||||
|
|
@ -1666,7 +1666,7 @@ static void tst_newton_interpolation() {
|
|||
polynomial_ref r(m);
|
||||
{
|
||||
polynomial::scoped_set_zp setZ97(m, 97);
|
||||
m.newton_interpolation(0, 2, ins.c_ptr(), outs, r);
|
||||
m.newton_interpolation(0, 2, ins.data(), outs, r);
|
||||
}
|
||||
std::cout << "interpolation result: " << r << "\n";
|
||||
ENSURE(m.eq((x^2)*y + 5*x*y + 41*x - 9*y - 21, r));
|
||||
|
|
@ -1721,17 +1721,17 @@ void tst_linear_solver() {
|
|||
|
||||
as.reset();
|
||||
as.push_back(mpq(2)); as.push_back(mpq(1)); as.push_back(mpq(-1)); qm.set(b, 8);
|
||||
solver.add(0, as.c_ptr(), b);
|
||||
solver.add(0, as.data(), b);
|
||||
|
||||
as.reset();
|
||||
as.push_back(mpq(-3)); as.push_back(mpq(-1)); as.push_back(mpq(2)); qm.set(b, -11);
|
||||
solver.add(1, as.c_ptr(), b);
|
||||
solver.add(1, as.data(), b);
|
||||
|
||||
as.reset();
|
||||
as.push_back(mpq(-2)); as.push_back(mpq(1)); as.push_back(mpq(2)); qm.set(b, -3);
|
||||
solver.add(2, as.c_ptr(), b);
|
||||
solver.add(2, as.data(), b);
|
||||
|
||||
VERIFY(solver.solve(xs.c_ptr()));
|
||||
VERIFY(solver.solve(xs.data()));
|
||||
ENSURE(qm.eq(xs[0], mpq(2)));
|
||||
ENSURE(qm.eq(xs[1], mpq(3)));
|
||||
ENSURE(qm.eq(xs[2], mpq(-1)));
|
||||
|
|
|
|||
|
|
@ -192,7 +192,7 @@ static app_ref generate_ineqs(ast_manager& m, sort* s, vector<expr_ref_vector>&
|
|||
static void test_c(app* x, expr_ref_vector const& c) {
|
||||
ast_manager& m = c.get_manager();
|
||||
expr_ref fml(m);
|
||||
fml = m.mk_and(c.size(), c.c_ptr());
|
||||
fml = m.mk_and(c.size(), c.data());
|
||||
test(x, fml);
|
||||
}
|
||||
|
||||
|
|
@ -261,8 +261,8 @@ static void test2(char const *ex) {
|
|||
names.push_back(vars[i]->get_decl()->get_name());
|
||||
sorts.push_back(vars[i]->get_sort());
|
||||
}
|
||||
expr_abstract(m, 0, bound.size(), bound.c_ptr(), fml, fml2);
|
||||
fml2 = m.mk_exists(bound.size(), sorts.c_ptr(), names.c_ptr(), fml2);
|
||||
expr_abstract(m, 0, bound.size(), bound.data(), fml, fml2);
|
||||
fml2 = m.mk_exists(bound.size(), sorts.data(), names.data(), fml2);
|
||||
qe::expr_quant_elim qe(m, params);
|
||||
for (unsigned i = 0; i < vars.size(); ++i) {
|
||||
VERIFY(mbp::arith_project(*md, vars[i].get(), lits));
|
||||
|
|
@ -303,7 +303,7 @@ static void mk_term(vector<var_t> const& vars, rational const& coeff, app_ref& t
|
|||
ts.push_back(a.mk_mul(a.mk_numeral(coeff, false), var));
|
||||
}
|
||||
ts.push_back(a.mk_numeral(coeff, a.mk_real()));
|
||||
term = a.mk_add(ts.size(), ts.c_ptr());
|
||||
term = a.mk_add(ts.size(), ts.data());
|
||||
}
|
||||
|
||||
static void add_random_ineq(
|
||||
|
|
@ -466,9 +466,9 @@ static void test_project() {
|
|||
nums.push_back(a.mk_int(0));
|
||||
nums.push_back(a.mk_int(1));
|
||||
nums.push_back(a.mk_int(2));
|
||||
fi->insert_new_entry(nums.c_ptr(), a.mk_int(1));
|
||||
fi->insert_new_entry(nums.c_ptr()+1, a.mk_int(2));
|
||||
fi->insert_new_entry(nums.c_ptr()+2, a.mk_int(3));
|
||||
fi->insert_new_entry(nums.data(), a.mk_int(1));
|
||||
fi->insert_new_entry(nums.data()+1, a.mk_int(2));
|
||||
fi->insert_new_entry(nums.data()+2, a.mk_int(3));
|
||||
fi->set_else(a.mk_int(10));
|
||||
mdl.register_decl(f, fi);
|
||||
vars.reset();
|
||||
|
|
@ -502,7 +502,7 @@ static void test_project() {
|
|||
ds.push_back(z + 2);
|
||||
ds.push_back(u);
|
||||
ds.push_back(z);
|
||||
lits.push_back(m.mk_not(m.mk_distinct(ds.size(), ds.c_ptr())));
|
||||
lits.push_back(m.mk_not(m.mk_distinct(ds.size(), ds.data())));
|
||||
plugin(mdl, vars, lits);
|
||||
std::cout << lits << "\n";
|
||||
|
||||
|
|
@ -522,7 +522,7 @@ static void test_project() {
|
|||
ds.push_back(u);
|
||||
ds.push_back(z + 10);
|
||||
ds.push_back(u + 4);
|
||||
lits.push_back(m.mk_not(m.mk_distinct(ds.size(), ds.c_ptr())));
|
||||
lits.push_back(m.mk_not(m.mk_distinct(ds.size(), ds.data())));
|
||||
plugin(mdl, vars, lits);
|
||||
std::cout << lits << "\n";
|
||||
|
||||
|
|
@ -541,7 +541,7 @@ static void test_project() {
|
|||
ds.push_back(y);
|
||||
ds.push_back(z + 2);
|
||||
ds.push_back(u);
|
||||
lits.push_back(m.mk_distinct(ds.size(), ds.c_ptr()));
|
||||
lits.push_back(m.mk_distinct(ds.size(), ds.data()));
|
||||
plugin(mdl, vars, lits);
|
||||
std::cout << lits << "\n";
|
||||
|
||||
|
|
|
|||
|
|
@ -146,7 +146,7 @@ static void parse_fml(char const* str, app_ref_vector& vars, expr_ref& fml) {
|
|||
}
|
||||
fml = q->get_expr();
|
||||
var_subst vs(m, true);
|
||||
fml = vs(fml, vars.size(), (expr*const*)vars.c_ptr());
|
||||
fml = vs(fml, vars.size(), (expr*const*)vars.data());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -164,7 +164,7 @@ static void test_quant_solver(ast_manager& m, char const* str, bool validate = t
|
|||
expr_ref fml(m);
|
||||
app_ref_vector vars(m);
|
||||
parse_fml(str, vars, fml);
|
||||
test_quant_solver(m, vars.size(), vars.c_ptr(), fml, validate);
|
||||
test_quant_solver(m, vars.size(), vars.data(), fml, validate);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ static void tst_solve(unsigned n, int _A[], int _b[], int _c[], bool solved) {
|
|||
A.set(i, j, _A[i*n + j]);
|
||||
svector<int> b;
|
||||
b.resize(n, 0);
|
||||
if (mm.solve(A, b.c_ptr(), _c)) {
|
||||
if (mm.solve(A, b.data(), _c)) {
|
||||
ENSURE(solved);
|
||||
for (unsigned i = 0; i < n; i++) {
|
||||
ENSURE(b[i] == _b[i]);
|
||||
|
|
@ -138,7 +138,7 @@ static void tst_lin_indep(unsigned m, unsigned n, int _A[], unsigned ex_sz, unsi
|
|||
unsigned_vector r;
|
||||
r.resize(A.n());
|
||||
scoped_mpz_matrix B(mm);
|
||||
mm.linear_independent_rows(A, r.c_ptr(), B);
|
||||
mm.linear_independent_rows(A, r.data(), B);
|
||||
for (unsigned i = 0; i < ex_sz; i++) {
|
||||
ENSURE(r[i] == ex_r[i]);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ static bool build_instance(char const * filename, sat::solver& s, sat::local_sea
|
|||
}
|
||||
infile >> k;
|
||||
//local_search.add_cardinality(lits.size(), lits.c_ptr(), static_cast<unsigned>(lits.size() - k));
|
||||
local_search.add_cardinality(lits.size(), lits.c_ptr(), static_cast<unsigned>(k));
|
||||
local_search.add_cardinality(lits.size(), lits.data(), static_cast<unsigned>(k));
|
||||
}
|
||||
|
||||
infile.close();
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ static void add_clause(sat::solver& s, random_gen& r, trail_t& t) {
|
|||
for (unsigned i = 0; i < 3; ++i) {
|
||||
add_literal(r, cls);
|
||||
}
|
||||
s.mk_clause(cls.size(), cls.c_ptr());
|
||||
s.mk_clause(cls.size(), cls.data());
|
||||
}
|
||||
|
||||
static void pop_user_scope(sat::solver& s, trail_t& t) {
|
||||
|
|
@ -63,7 +63,7 @@ static void check_coherence(sat::solver& s1, trail_t& t) {
|
|||
for (unsigned j = 0; j < clss.size(); ++j) {
|
||||
cls.reset();
|
||||
cls.append(clss[j]);
|
||||
s2.mk_clause(cls.size(), cls.c_ptr());
|
||||
s2.mk_clause(cls.size(), cls.data());
|
||||
}
|
||||
}
|
||||
lbool is_sat1 = s1.check();
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ void add_row(Simplex& S, vector<R> const& _v, R const& _b, bool is_eq = false) {
|
|||
if (is_eq) S.set_upper(nv, zero);
|
||||
S.set_lower(nv+1, one);
|
||||
S.set_upper(nv+1, one);
|
||||
S.add_row(nv, coeffs.size(), vars.c_ptr(), coeffs.c_ptr());
|
||||
S.add_row(nv, coeffs.size(), vars.data(), coeffs.data());
|
||||
}
|
||||
|
||||
static void feas(Simplex& S) {
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ void tst_smt_context()
|
|||
ptr_vector<expr> assumptions;
|
||||
assumptions.push_back(nc.get());
|
||||
|
||||
ctx.check(assumptions.size(), assumptions.c_ptr());
|
||||
ctx.check(assumptions.size(), assumptions.data());
|
||||
}
|
||||
|
||||
ctx.check();
|
||||
|
|
|
|||
|
|
@ -196,7 +196,7 @@ static void test_eq1(unsigned n, sorting_network_encoding enc) {
|
|||
|
||||
// equality:
|
||||
solver.push();
|
||||
result1 = sn.eq(true, 1, in.size(), in.c_ptr());
|
||||
result1 = sn.eq(true, 1, in.size(), in.data());
|
||||
for (expr* cls : ext.m_clauses) {
|
||||
solver.assert_expr(cls);
|
||||
}
|
||||
|
|
@ -242,7 +242,7 @@ static void test_sorting_eq(unsigned n, unsigned k, sorting_network_encoding enc
|
|||
// equality:
|
||||
std::cout << "eq " << k << " out of " << n << " for encoding " << enc << "\n";
|
||||
solver.push();
|
||||
result = sn.eq(false, k, in.size(), in.c_ptr());
|
||||
result = sn.eq(false, k, in.size(), in.data());
|
||||
solver.assert_expr(result);
|
||||
for (expr* cl : ext.m_clauses) {
|
||||
solver.assert_expr(cl);
|
||||
|
|
@ -297,7 +297,7 @@ static void test_sorting_le(unsigned n, unsigned k, sorting_network_encoding enc
|
|||
// B <= k
|
||||
std::cout << "le " << k << "\n";
|
||||
solver.push();
|
||||
result = sn.le(false, k, in.size(), in.c_ptr());
|
||||
result = sn.le(false, k, in.size(), in.data());
|
||||
solver.assert_expr(result);
|
||||
for (expr* cls : ext.m_clauses) {
|
||||
solver.assert_expr(cls);
|
||||
|
|
@ -355,7 +355,7 @@ void test_sorting_ge(unsigned n, unsigned k, sorting_network_encoding enc) {
|
|||
// k <= B
|
||||
std::cout << "ge " << k << "\n";
|
||||
solver.push();
|
||||
result = sn.ge(false, k, in.size(), in.c_ptr());
|
||||
result = sn.ge(false, k, in.size(), in.data());
|
||||
solver.assert_expr(result);
|
||||
for (expr* cls : ext.m_clauses) {
|
||||
solver.assert_expr(cls);
|
||||
|
|
@ -416,7 +416,7 @@ void test_at_most_1(unsigned n, bool full, sorting_network_encoding enc) {
|
|||
psort_nw<ast_ext2> sn(ext);
|
||||
sn.cfg().m_encoding = enc;
|
||||
expr_ref result1(m), result2(m);
|
||||
result1 = sn.le(full, 1, in.size(), in.c_ptr());
|
||||
result1 = sn.le(full, 1, in.size(), in.data());
|
||||
result2 = naive_at_most1(in);
|
||||
|
||||
|
||||
|
|
@ -494,7 +494,7 @@ static void test_at_most1(sorting_network_encoding enc) {
|
|||
psort_nw<ast_ext2> sn(ext);
|
||||
sn.cfg().m_encoding = enc;
|
||||
expr_ref result(m);
|
||||
result = sn.le(true, 1, in.size(), in.c_ptr());
|
||||
result = sn.le(true, 1, in.size(), in.data());
|
||||
//std::cout << result << "\n";
|
||||
//std::cout << ext.m_clauses << "\n";
|
||||
}
|
||||
|
|
@ -557,7 +557,7 @@ static void test_pb(unsigned max_w, unsigned sz, unsigned_vector& ws) {
|
|||
solver.push();
|
||||
//std::cout << "bound: " << k << "\n";
|
||||
//std::cout << ws << " " << xs << "\n";
|
||||
ge = sn.ge(k, sz, ws.c_ptr(), xs.c_ptr());
|
||||
ge = sn.ge(k, sz, ws.data(), xs.data());
|
||||
//std::cout << "ge: " << ge << "\n";
|
||||
for (expr* cls : ext.m_clauses) {
|
||||
solver.assert_expr(cls);
|
||||
|
|
@ -606,7 +606,7 @@ static void test_pb(unsigned max_w, unsigned sz, unsigned_vector& ws) {
|
|||
solver.pop(1);
|
||||
|
||||
solver.push();
|
||||
eq = sn.eq(k, sz, ws.c_ptr(), xs.c_ptr());
|
||||
eq = sn.eq(k, sz, ws.data(), xs.data());
|
||||
|
||||
for (expr* cls : ext.m_clauses) {
|
||||
solver.assert_expr(cls);
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ void tst_substitution()
|
|||
sorts.push_back(m.mk_bool_sort());
|
||||
names.push_back(symbol("dude"));
|
||||
body = m.mk_and(m.mk_eq(v1,v2), m.mk_eq(v3,v4));
|
||||
q = m.mk_forall(sorts.size(), sorts.c_ptr(), names.c_ptr(), body);
|
||||
q = m.mk_forall(sorts.size(), sorts.data(), names.data(), body);
|
||||
subst.apply(q, res);
|
||||
TRACE("substitution", tout << mk_pp(q, m) << "\n->\n" << mk_pp(res, m) << "\n";);
|
||||
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ private:
|
|||
k += coeffs[i];
|
||||
}
|
||||
}
|
||||
fml = pb.mk_ge(args.size(), coeffs.c_ptr(), args.c_ptr(), k);
|
||||
fml = pb.mk_ge(args.size(), coeffs.data(), args.data(), k);
|
||||
rw(fml, tmp);
|
||||
rw(tmp, tmp);
|
||||
if (pb.is_ge(tmp)) {
|
||||
|
|
@ -142,7 +142,7 @@ void tst_theory_pb() {
|
|||
{
|
||||
smt::context ctx(m, params);
|
||||
ctx.push();
|
||||
smt::literal l = smt::theory_pb::assert_ge(ctx, k+1, lits.size(), lits.c_ptr());
|
||||
smt::literal l = smt::theory_pb::assert_ge(ctx, k+1, lits.size(), lits.data());
|
||||
if (l != smt::false_literal) {
|
||||
ctx.assign(l, nullptr, false);
|
||||
TRACE("pb", tout << "assign: " << l << "\n";
|
||||
|
|
@ -154,7 +154,7 @@ void tst_theory_pb() {
|
|||
{
|
||||
smt::context ctx(m, params);
|
||||
ctx.push();
|
||||
smt::literal l = smt::theory_pb::assert_ge(ctx, k, lits.size(), lits.c_ptr());
|
||||
smt::literal l = smt::theory_pb::assert_ge(ctx, k, lits.size(), lits.data());
|
||||
ENSURE(l != smt::false_literal);
|
||||
ctx.assign(l, nullptr, false);
|
||||
TRACE("pb", ctx.display(tout););
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ public:
|
|||
|
||||
udoc_relation* mk_full(relation_signature const& sig) {
|
||||
func_decl_ref fn(m);
|
||||
fn = m.mk_func_decl(symbol("full"), sig.size(), sig.c_ptr(), m.mk_bool_sort());
|
||||
fn = m.mk_func_decl(symbol("full"), sig.size(), sig.data(), m.mk_bool_sort());
|
||||
relation_base* full = p.mk_full(fn, sig);
|
||||
return dynamic_cast<udoc_relation*>(full);
|
||||
}
|
||||
|
|
@ -209,7 +209,7 @@ public:
|
|||
unsigned_vector jc1, jc2;
|
||||
jc1.push_back(1);
|
||||
jc2.push_back(1);
|
||||
datalog::relation_join_fn* join_fn = p.mk_join_fn(*t1, *t2, jc1.size(), jc1.c_ptr(), jc2.c_ptr());
|
||||
datalog::relation_join_fn* join_fn = p.mk_join_fn(*t1, *t2, jc1.size(), jc1.data(), jc2.data());
|
||||
ENSURE(join_fn);
|
||||
t = (*join_fn)(*t1, *t2);
|
||||
cr.verify_join(*t1, *t2, *t, jc1, jc2);
|
||||
|
|
@ -240,7 +240,7 @@ public:
|
|||
t1 = mk_full(sig);
|
||||
unsigned_vector pc;
|
||||
pc.push_back(0);
|
||||
datalog::relation_transformer_fn* proj_fn = p.mk_project_fn(*t1, pc.size(), pc.c_ptr());
|
||||
datalog::relation_transformer_fn* proj_fn = p.mk_project_fn(*t1, pc.size(), pc.data());
|
||||
t = (*proj_fn)(*t1);
|
||||
cr.verify_project(*t1, *t, pc);
|
||||
t->display(std::cout); std::cout << "\n";
|
||||
|
|
@ -298,7 +298,7 @@ public:
|
|||
id.push_back(0);
|
||||
id.push_back(2);
|
||||
id.push_back(4);
|
||||
rel_mut filter_id = p.mk_filter_identical_fn(*t1, id.size(), id.c_ptr());
|
||||
rel_mut filter_id = p.mk_filter_identical_fn(*t1, id.size(), id.data());
|
||||
relation_fact f1(m);
|
||||
f1.push_back(bv.mk_numeral(rational(1),3));
|
||||
f1.push_back(bv.mk_numeral(rational(1),6));
|
||||
|
|
@ -468,7 +468,7 @@ public:
|
|||
t2 = mk_rand(sig);
|
||||
t1->display(std::cout);
|
||||
t2->display(std::cout);
|
||||
join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.c_ptr(), jc2.c_ptr(), pc.size(), pc.c_ptr());
|
||||
join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.data(), jc2.data(), pc.size(), pc.data());
|
||||
t = (*join_project_fn)(*t1, *t2);
|
||||
t->display(std::cout);
|
||||
cr.verify_join_project(*t1, *t2, *t, jc1, jc2, pc);
|
||||
|
|
@ -518,7 +518,7 @@ public:
|
|||
pc.push_back(2);
|
||||
|
||||
scoped_ptr<datalog::relation_join_fn> join_project_fn;
|
||||
join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.c_ptr(), jc2.c_ptr(), pc.size(), pc.c_ptr());
|
||||
join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.data(), jc2.data(), pc.size(), pc.data());
|
||||
relation_base *t = (*join_project_fn)(*t1, *t2);
|
||||
cr.verify_join_project(*t1, *t2, *t, jc1, jc2, pc);
|
||||
t->deallocate();
|
||||
|
|
@ -564,7 +564,7 @@ public:
|
|||
|
||||
t1->display(std::cout << "t1:");
|
||||
t2->display(std::cout << "t2:");
|
||||
join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.c_ptr(), jc2.c_ptr(), pc.size(), pc.c_ptr());
|
||||
join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.data(), jc2.data(), pc.size(), pc.data());
|
||||
|
||||
relation_base* t;
|
||||
t = (*join_project_fn)(*t1, *t2);
|
||||
|
|
@ -638,7 +638,7 @@ public:
|
|||
jc2.push_back(0);
|
||||
scoped_ptr<datalog::relation_join_fn> join_fn;
|
||||
|
||||
join_fn = p.mk_join_fn(*t1, *t2, jc1.size(), jc1.c_ptr(), jc2.c_ptr());
|
||||
join_fn = p.mk_join_fn(*t1, *t2, jc1.size(), jc1.data(), jc2.data());
|
||||
t = (*join_fn)(*t1, *t2);
|
||||
|
||||
cr.verify_join(*t1, *t2, *t, jc1, jc2);
|
||||
|
|
@ -659,7 +659,7 @@ public:
|
|||
|
||||
void check_permutation(relation_base* t1, unsigned_vector const& cycle) {
|
||||
scoped_ptr<datalog::relation_transformer_fn> rename;
|
||||
rename = p.mk_rename_fn(*t1, cycle.size(), cycle.c_ptr());
|
||||
rename = p.mk_rename_fn(*t1, cycle.size(), cycle.data());
|
||||
relation_base* t = (*rename)(*t1);
|
||||
cr.verify_permutation(*t1,*t, cycle);
|
||||
t1->display(std::cout); std::cout << "\n";
|
||||
|
|
@ -829,7 +829,7 @@ public:
|
|||
cols3.push_back(1);
|
||||
udoc_relation* tgt = mk_full(sig1);
|
||||
udoc_relation* neg = mk_full(sig2);
|
||||
rel_mut filter_id = p.mk_filter_identical_fn(*tgt, cols3.size(), cols3.c_ptr());
|
||||
rel_mut filter_id = p.mk_filter_identical_fn(*tgt, cols3.size(), cols3.data());
|
||||
(*filter_id)(*tgt);
|
||||
if (disable_fast) p.disable_fast_pass();
|
||||
apply_filter_neg(*tgt, *neg, cols1, cols2);
|
||||
|
|
@ -859,7 +859,7 @@ public:
|
|||
unsigned_vector const& cols1, unsigned_vector const& cols2) {
|
||||
|
||||
scoped_ptr<datalog::relation_intersection_filter_fn> negf;
|
||||
negf = p.mk_filter_by_negation_fn(dst, neg, cols1.size(), cols1.c_ptr(), cols2.c_ptr());
|
||||
negf = p.mk_filter_by_negation_fn(dst, neg, cols1.size(), cols1.data(), cols2.data());
|
||||
expr_ref dst0(m);
|
||||
dst.to_formula(dst0);
|
||||
(*negf)(dst, neg);
|
||||
|
|
@ -880,7 +880,7 @@ public:
|
|||
|
||||
void apply_filter_project(udoc_relation& t, unsigned_vector const& rm, app* cond) {
|
||||
scoped_ptr<datalog::relation_transformer_fn> rt;
|
||||
rt = p.mk_filter_interpreted_and_project_fn(t, cond, rm.size(), rm.c_ptr());
|
||||
rt = p.mk_filter_interpreted_and_project_fn(t, cond, rm.size(), rm.data());
|
||||
datalog::relation_base* result = (*rt)(t);
|
||||
cr.verify_filter_project(t, *result, cond, rm);
|
||||
result->deallocate();
|
||||
|
|
@ -900,7 +900,7 @@ public:
|
|||
repl(tmp);
|
||||
disj.push_back(tmp);
|
||||
}
|
||||
fml = mk_or(m, disj.size(), disj.c_ptr());
|
||||
fml = mk_or(m, disj.size(), disj.data());
|
||||
}
|
||||
|
||||
void apply_filter(udoc_relation& t, app* cond) {
|
||||
|
|
|
|||
|
|
@ -57,11 +57,11 @@ static void tst1() {
|
|||
std::cout << "new q: "; um.display(std::cout, q); std::cout << "\n";
|
||||
|
||||
// q^2
|
||||
um.mul(q.size(), q.c_ptr(), q.size(), q.c_ptr(), q);
|
||||
um.mul(q.size(), q.data(), q.size(), q.data(), q);
|
||||
std::cout << "new q^2: "; um.display(std::cout, q); std::cout << "\n";
|
||||
|
||||
// using pw for (q^2)^3
|
||||
um.pw(q.size(), q.c_ptr(), 3, q);
|
||||
um.pw(q.size(), q.data(), 3, q);
|
||||
std::cout << "new (q^2)^3: "; um.display(std::cout, q); std::cout << "\n";
|
||||
}
|
||||
|
||||
|
|
@ -73,13 +73,13 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
std::cout << "isolating roots of: "; um.display(std::cout, q); std::cout << "\n";
|
||||
{
|
||||
timeit timer(true, "isolate time");
|
||||
um.isolate_roots(q.size(), q.c_ptr(), bqm, roots, lowers, uppers);
|
||||
um.isolate_roots(q.size(), q.data(), bqm, roots, lowers, uppers);
|
||||
}
|
||||
|
||||
upolynomial::scoped_upolynomial_sequence sseq(um), fseq(um);
|
||||
{
|
||||
timeit timer(true, "sturm time");
|
||||
um.sturm_seq(q.size(), q.c_ptr(), sseq);
|
||||
um.sturm_seq(q.size(), q.data(), sseq);
|
||||
// um.display(std::cout, sseq); std::cout << "\n";
|
||||
}
|
||||
|
||||
|
|
@ -87,13 +87,13 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
upolynomial::scoped_numeral_vector q_sqf(um);
|
||||
{
|
||||
timeit timer(true, "sqf time");
|
||||
um.square_free(q.size(), q.c_ptr(), q_sqf);
|
||||
um.square_free(q.size(), q.data(), q_sqf);
|
||||
std::cout << "square free part: "; um.display(std::cout, q_sqf); std::cout << "\n";
|
||||
}
|
||||
|
||||
{
|
||||
timeit timer(true, "fourier time");
|
||||
um.fourier_seq(q_sqf.size(), q_sqf.c_ptr(), fseq);
|
||||
um.fourier_seq(q_sqf.size(), q_sqf.data(), fseq);
|
||||
}
|
||||
|
||||
// um.display(std::cout, fseq);
|
||||
|
|
@ -104,7 +104,7 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
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++) {
|
||||
ENSURE(um.eval_sign_at(q.size(), q.c_ptr(), roots[i]) == 0);
|
||||
ENSURE(um.eval_sign_at(q.size(), q.data(), roots[i]) == 0);
|
||||
std::cout << " "; bqm.display_decimal(std::cout, roots[i], prec);
|
||||
}
|
||||
{
|
||||
|
|
@ -118,8 +118,8 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
bqm.display_decimal(std::cout, uppers[i], prec);
|
||||
std::cout << ")";
|
||||
// Check interval with Sturm sequence. Small detail: Sturm sequence is for close intervals.
|
||||
ENSURE(um.eval_sign_at(q.size(), q.c_ptr(), lowers[i]) == 0 ||
|
||||
um.eval_sign_at(q.size(), q.c_ptr(), uppers[i]) == 0 ||
|
||||
ENSURE(um.eval_sign_at(q.size(), q.data(), lowers[i]) == 0 ||
|
||||
um.eval_sign_at(q.size(), q.data(), uppers[i]) == 0 ||
|
||||
um.sign_variations_at(sseq, lowers[i]) - um.sign_variations_at(sseq, uppers[i]) == 1);
|
||||
// Fourier sequence may also be used to check if the interval is isolating
|
||||
TRACE("upolynomial",
|
||||
|
|
@ -129,8 +129,8 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
tout << "fourier upper: " << um.sign_variations_at(fseq, uppers[i]) << "\n";);
|
||||
unsigned fsv_lower = um.sign_variations_at(fseq, lowers[i]);
|
||||
unsigned fsv_upper = um.sign_variations_at(fseq, uppers[i]);
|
||||
VERIFY(um.eval_sign_at(q.size(), q.c_ptr(), lowers[i]) == 0 ||
|
||||
um.eval_sign_at(q.size(), q.c_ptr(), uppers[i]) == 0 ||
|
||||
VERIFY(um.eval_sign_at(q.size(), q.data(), lowers[i]) == 0 ||
|
||||
um.eval_sign_at(q.size(), q.data(), uppers[i]) == 0 ||
|
||||
// fsv_lower - fsv_upper is an upper bound for the number of roots in the interval
|
||||
// fsv_upper - fsv_upper - num_roots is even
|
||||
// Recall that num_roots == 1 in the interval.
|
||||
|
|
@ -138,7 +138,7 @@ static void tst_isolate_roots(polynomial_ref const & p, unsigned prec, mpbq_mana
|
|||
|
||||
// Double checking using Descartes bounds for the interval
|
||||
// Must use square free component.
|
||||
unsigned dab = um.descartes_bound_a_b(q_sqf.size(), q_sqf.c_ptr(), bqm, lowers[i], uppers[i]);
|
||||
unsigned dab = um.descartes_bound_a_b(q_sqf.size(), q_sqf.data(), bqm, lowers[i], uppers[i]);
|
||||
TRACE("upolynomial", tout << "Descartes bound: " << dab << "\n";);
|
||||
VERIFY(dab == 1);
|
||||
}
|
||||
|
|
@ -292,9 +292,9 @@ static void tst_remove_one_half() {
|
|||
upolynomial::scoped_numeral_vector _p(um), _q(um), _r(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
um.to_numeral_vector(r, _r);
|
||||
ENSURE(um.has_one_half_root(_p.size(), _p.c_ptr()));
|
||||
um.remove_one_half_root(_p.size(), _p.c_ptr(), _q);
|
||||
ENSURE(!um.has_one_half_root(_q.size(), _q.c_ptr()));
|
||||
ENSURE(um.has_one_half_root(_p.size(), _p.data()));
|
||||
um.remove_one_half_root(_p.size(), _p.data(), _q);
|
||||
ENSURE(!um.has_one_half_root(_q.size(), _q.data()));
|
||||
std::cout << "_p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
std::cout << "_r: "; um.display(std::cout, _r); std::cout << "\n";
|
||||
std::cout << "_q: "; um.display(std::cout, _q); std::cout << "\n";
|
||||
|
|
@ -302,11 +302,11 @@ static void tst_remove_one_half() {
|
|||
|
||||
p = (((x^5) - 1000000000)^3)*((3*x - 10000000)^2)*((10*x - 632)^2);
|
||||
um.to_numeral_vector(p, _p);
|
||||
ENSURE(!um.has_one_half_root(_p.size(), _p.c_ptr()));
|
||||
ENSURE(!um.has_one_half_root(_p.size(), _p.data()));
|
||||
|
||||
p = (x - 2)*(x - 4)*(x - 8)*(x - 16)*(x - 32)*(x - 64)*(2*x - 1)*(4*x - 1)*(8*x - 1)*(16*x - 1)*(32*x - 1);
|
||||
um.to_numeral_vector(p, _p);
|
||||
ENSURE(um.has_one_half_root(_p.size(), _p.c_ptr()));
|
||||
ENSURE(um.has_one_half_root(_p.size(), _p.data()));
|
||||
}
|
||||
|
||||
template<typename pmanager>
|
||||
|
|
@ -316,9 +316,9 @@ static void tst_gcd(polynomial_ref const & p, polynomial_ref const & q, pmanager
|
|||
um.to_numeral_vector(q, _q);
|
||||
std::cout << "_p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
std::cout << "_q: "; um.display(std::cout, _q); std::cout << std::endl;
|
||||
um.gcd(_p.size(), _p.c_ptr(), _q.size(), _q.c_ptr(), _r);
|
||||
um.gcd(_p.size(), _p.data(), _q.size(), _q.data(), _r);
|
||||
std::cout << "gcd: "; um.display(std::cout, _r); std::cout << "\n";
|
||||
um.subresultant_gcd(_p.size(), _p.c_ptr(), _q.size(), _q.c_ptr(), _r);
|
||||
um.subresultant_gcd(_p.size(), _p.data(), _q.size(), _q.data(), _r);
|
||||
std::cout << "_p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
std::cout << "_q: "; um.display(std::cout, _q); std::cout << "\n";
|
||||
std::cout << "subresultant_gcd: "; um.display(std::cout, _r); std::cout << "\n";
|
||||
|
|
@ -426,7 +426,7 @@ static void tst_ext_gcd() {
|
|||
upolynomial::zp_manager::scoped_numeral_vector A(z13), B(z13), U(z13), V(z13), D(z13);
|
||||
um.to_numeral_vector(a, A);
|
||||
um.to_numeral_vector(b, B);
|
||||
um.ext_gcd(A.size(), A.c_ptr(), B.size(), B.c_ptr(), U, V, D);
|
||||
um.ext_gcd(A.size(), A.data(), B.size(), B.data(), U, V, D);
|
||||
std::cout << "A: "; um.display(std::cout, A); std::cout << "\n";
|
||||
std::cout << "B: "; um.display(std::cout, B); std::cout << "\n";
|
||||
std::cout << "U: "; um.display(std::cout, U); std::cout << "\n";
|
||||
|
|
@ -457,7 +457,7 @@ static void tst_ext_gcd_z7() {
|
|||
upolynomial::zp_manager::scoped_numeral_vector A(z7), B(z7), U(z7), V(z7), D(z7);
|
||||
um.to_numeral_vector(a, A);
|
||||
um.to_numeral_vector(b, B);
|
||||
um.ext_gcd(A.size(), A.c_ptr(), B.size(), B.c_ptr(), U, V, D);
|
||||
um.ext_gcd(A.size(), A.data(), B.size(), B.data(), U, V, D);
|
||||
std::cout << "A: "; um.display(std::cout, A); std::cout << "\n";
|
||||
std::cout << "B: "; um.display(std::cout, B); std::cout << "\n";
|
||||
std::cout << "U: "; um.display(std::cout, U); std::cout << "\n";
|
||||
|
|
@ -482,7 +482,7 @@ static void tst_sturm() {
|
|||
upolynomial::scoped_numeral_vector _p(um);
|
||||
upolynomial::scoped_upolynomial_sequence seq2(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
um.sturm_seq(_p.size(), _p.c_ptr(), seq2);
|
||||
um.sturm_seq(_p.size(), _p.data(), seq2);
|
||||
std::cout << "upolynomial sturm seq...\n";
|
||||
um.display(std::cout, seq2);
|
||||
}
|
||||
|
|
@ -494,16 +494,16 @@ static void tst_refinable(polynomial_ref const & p, mpbq_manager & bqm, mpbq & a
|
|||
upolynomial::scoped_numeral_vector _p(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
std::cout << "before (" << bqm.to_string(a) << ", " << bqm.to_string(b) << ")\n";
|
||||
bool r = um.isolating2refinable(_p.size(), _p.c_ptr(), bqm, a, b);
|
||||
bool r = um.isolating2refinable(_p.size(), _p.data(), bqm, a, b);
|
||||
if (r) {
|
||||
std::cout << "new (" << bqm.to_string(a) << ", " << bqm.to_string(b) << ")\n";
|
||||
int sign_a = um.eval_sign_at(_p.size(), _p.c_ptr(), a);
|
||||
int sign_b = um.eval_sign_at(_p.size(), _p.c_ptr(), b);
|
||||
int sign_a = um.eval_sign_at(_p.size(), _p.data(), a);
|
||||
int sign_b = um.eval_sign_at(_p.size(), _p.data(), b);
|
||||
VERIFY(sign_a != 0 && sign_b != 0 && sign_a == -sign_b);
|
||||
}
|
||||
else {
|
||||
std::cout << "new root: " << bqm.to_string(a) << "\n";
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), a) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), a) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -561,7 +561,7 @@ static void tst_refine(polynomial_ref const & p, mpbq_manager & bqm, mpbq & a, m
|
|||
upolynomial::scoped_numeral_vector _p(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
std::cout << "before (" << bqm.to_string(a) << ", " << bqm.to_string(b) << ")\n";
|
||||
bool r = um.refine(_p.size(), _p.c_ptr(), bqm, a, b, prec_k);
|
||||
bool r = um.refine(_p.size(), _p.data(), bqm, a, b, prec_k);
|
||||
if (r) {
|
||||
std::cout << "new (" << bqm.to_string(a) << ", " << bqm.to_string(b) << ")\n";
|
||||
std::cout << "as decimal: "; bqm.display_decimal(std::cout, a, prec_k); std::cout << "\n";
|
||||
|
|
@ -608,13 +608,13 @@ static void tst_translate_q() {
|
|||
upolynomial::manager um(rl, nm);
|
||||
upolynomial::scoped_numeral_vector _p(um), _q(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(1)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(2)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(3)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(4)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(-1)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(5)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(-2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(1)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(2)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(3)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(4)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(-1)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(5)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(-2)) != 0);
|
||||
scoped_mpq c(nm);
|
||||
nm.set(c, 1, 3);
|
||||
scoped_mpq r1(nm);
|
||||
|
|
@ -623,32 +623,32 @@ static void tst_translate_q() {
|
|||
scoped_mpq r2(nm);
|
||||
r2 = 3;
|
||||
r2 -= c;
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), r1) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), r2) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), r1) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), r2) != 0);
|
||||
std::cout << "p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
um.translate_q(_p.size(), _p.c_ptr(), c, _q);
|
||||
um.translate_q(_p.size(), _p.data(), c, _q);
|
||||
std::cout << "q: "; um.display(std::cout, _q); std::cout << "\n";
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(1)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(3)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(4)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(-1)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(5)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), mpq(-2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), r1) == 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.c_ptr(), r2) == 0);
|
||||
um.p_1_div_x(_p.size(), _p.c_ptr());
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(1)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(3)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(4)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(-1)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(5)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), mpq(-2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), r1) == 0);
|
||||
ENSURE(um.eval_sign_at(_q.size(), _q.data(), r2) == 0);
|
||||
um.p_1_div_x(_p.size(), _p.data());
|
||||
std::cout << "p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(1)) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(1)) == 0);
|
||||
nm.set(c, 1, 2);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), c) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), c) == 0);
|
||||
nm.set(c, 1, 3);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), c) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), c) == 0);
|
||||
nm.set(c, 1, 4);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), c) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(3)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.c_ptr(), mpq(4)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), c) == 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(2)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(3)) != 0);
|
||||
ENSURE(um.eval_sign_at(_p.size(), _p.data(), mpq(4)) != 0);
|
||||
}
|
||||
|
||||
static void tst_convert_q2bq(unsynch_mpq_manager & m, polynomial_ref const & p, mpq const & a, mpq const & b) {
|
||||
|
|
@ -663,7 +663,7 @@ static void tst_convert_q2bq(unsynch_mpq_manager & m, polynomial_ref const & p,
|
|||
mpbq_manager bqm(m);
|
||||
scoped_mpbq c(bqm);
|
||||
scoped_mpbq d(bqm);
|
||||
if (!um.convert_q2bq_interval(_p.size(), _p.c_ptr(), a, b, bqm, c, d)) {
|
||||
if (!um.convert_q2bq_interval(_p.size(), _p.data(), a, b, bqm, c, d)) {
|
||||
std::cout << "found root: " << c << "\n";
|
||||
}
|
||||
else {
|
||||
|
|
@ -738,7 +738,7 @@ static void tst_sturm2() {
|
|||
upolynomial::scoped_upolynomial_sequence seq2(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
um.to_numeral_vector(q, _q);
|
||||
um.sturm_tarski_seq(_p.size(), _p.c_ptr(), _q.size(), _q.c_ptr(), seq2);
|
||||
um.sturm_tarski_seq(_p.size(), _p.data(), _q.size(), _q.data(), seq2);
|
||||
|
||||
std::cout << "upolynomial sturm seq...\n";
|
||||
um.display(std::cout, seq2);
|
||||
|
|
@ -840,7 +840,7 @@ static void tst_exact_div(polynomial_ref const & p1, polynomial_ref const & p2,
|
|||
std::cout << "------\n";
|
||||
std::cout << "p1: "; um.display(std::cout, _p1); std::cout << "\n";
|
||||
std::cout << "p2: "; um.display(std::cout, _p2); std::cout << std::endl;
|
||||
bool res = um.exact_div(_p1.size(), _p1.c_ptr(), _p2.size(), _p2.c_ptr(), _r);
|
||||
bool res = um.exact_div(_p1.size(), _p1.data(), _p2.size(), _p2.data(), _r);
|
||||
if (res) {
|
||||
std::cout << "r: "; um.display(std::cout, _r); std::cout << "\n";
|
||||
}
|
||||
|
|
@ -849,7 +849,7 @@ static void tst_exact_div(polynomial_ref const & p1, polynomial_ref const & p2,
|
|||
}
|
||||
std::cout.flush();
|
||||
ENSURE(res == expected);
|
||||
ENSURE(expected == um.divides(_p1.size(), _p1.c_ptr(), _p2.size(), _p2.c_ptr()));
|
||||
ENSURE(expected == um.divides(_p1.size(), _p1.data(), _p2.size(), _p2.data()));
|
||||
ENSURE(!expected || um.eq(_r, _q));
|
||||
}
|
||||
|
||||
|
|
@ -1002,9 +1002,9 @@ static void tst_rem(polynomial_ref const & p, polynomial_ref const & q, polynomi
|
|||
upolynomial::scoped_numeral_vector _p(um), _q(um), _r(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
um.to_numeral_vector(q, _q);
|
||||
um.rem(_p.size(), _p.c_ptr(), _q.size(), _q.c_ptr(), _r);
|
||||
um.rem(_p.size(), _p.data(), _q.size(), _q.data(), _r);
|
||||
polynomial_ref r(p.m());
|
||||
r = p.m().to_polynomial(_r.size(), _r.c_ptr(), 0);
|
||||
r = p.m().to_polynomial(_r.size(), _r.data(), 0);
|
||||
std::cout << "r: " << r << std::endl;
|
||||
ENSURE(eq(expected, r));
|
||||
}
|
||||
|
|
@ -1030,7 +1030,7 @@ static void tst_lower_bound(polynomial_ref const & p) {
|
|||
upolynomial::scoped_numeral_vector _p(um);
|
||||
um.to_numeral_vector(p, _p);
|
||||
std::cout << "_p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
unsigned k = um.nonzero_root_lower_bound(_p.size(), _p.c_ptr());
|
||||
unsigned k = um.nonzero_root_lower_bound(_p.size(), _p.data());
|
||||
std::cout << "_p: "; um.display(std::cout, _p); std::cout << "\n";
|
||||
std::cout << "k: " << k << "\n";
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ void tst_instantiate(ast_manager & m, expr * f) {
|
|||
expr_ref_vector cnsts(m);
|
||||
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.c_ptr());
|
||||
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";);
|
||||
}
|
||||
}
|
||||
|
|
@ -82,7 +82,7 @@ void tst_subst(ast_manager& m) {
|
|||
sub1.push_back(x);
|
||||
sub1.push_back(y);
|
||||
// replace #1 -> #2, #2 -> #1
|
||||
e3 = subst(e2, 2, sub1.c_ptr());
|
||||
e3 = subst(e2, 2, sub1.data());
|
||||
std::cout << mk_pp(e2, m) << "\n";
|
||||
std::cout << mk_pp(e3, m) << "\n";
|
||||
std::cout << mk_pp(t1, m) << "\n";
|
||||
|
|
@ -90,7 +90,7 @@ void tst_subst(ast_manager& m) {
|
|||
|
||||
// replace #2 -> #3, #3 -> #2
|
||||
e2 = m.mk_forall(2, ss, names, e1);
|
||||
e3 = subst(e2, 2, sub1.c_ptr());
|
||||
e3 = subst(e2, 2, sub1.data());
|
||||
std::cout << mk_pp(e2, m) << "\n";
|
||||
std::cout << mk_pp(e3, m) << "\n";
|
||||
std::cout << mk_pp(t2, m) << "\n";
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue