relation_mutator_fn * sieve_relation_plugin::mk_filter_interpreted_fn(const relation_base & rb, app * condition) { if(&rb.get_plugin()!=this) { return 0; } ast_manager & m = get_ast_manager(); const sieve_relation & r = static_cast<const sieve_relation &>(rb); const relation_signature sig = r.get_signature(); unsigned sz = sig.size(); var_idx_set& cond_vars = get_context().get_rule_manager().collect_vars(condition); expr_ref_vector subst_vect(m); subst_vect.resize(sz); unsigned subst_ofs = sz-1; for(unsigned i=0; i<sz; i++) { if(!cond_vars.contains(i)) { continue; } if(!r.is_inner_col(i)) { //If the condition involves columns which do not belong to the inner relation, //we do nothing (which introduces imprecision). //Maybe we might try to do some quantifier elimination... return alloc(identity_relation_mutator_fn); } subst_vect[subst_ofs-i] = m.mk_var(r.m_sig2inner[i], sig[i]); } expr_ref inner_cond(m); get_context().get_var_subst()(condition, subst_vect.size(), subst_vect.c_ptr(), inner_cond); relation_mutator_fn * inner_fun = get_manager().mk_filter_interpreted_fn(r.get_inner(), to_app(inner_cond)); if(!inner_fun) { return 0; } return alloc(filter_fn, inner_fun); }
sort* external_relation_plugin::get_relation_sort(relation_signature const& sig) { vector<parameter> sorts; ast_manager& m = get_ast_manager(); family_id fid = get_family_id(); for (unsigned i = 0; i < sig.size(); ++i) { sorts.push_back(parameter(sig[i])); } return m.mk_sort(fid, DL_RELATION_SORT, sorts.size(), sorts.c_ptr()); }
table_mutator_fn * lazy_table_plugin::mk_filter_interpreted_fn( const table_base & t, app* condition) { if (check_kind(t)) { app_ref cond(condition, get_ast_manager()); return alloc(filter_interpreted_fn, cond); } else { return 0; } }
relation_base * external_relation_plugin::mk_empty(const relation_signature & s) { ast_manager& m = get_ast_manager(); sort* r_sort = get_relation_sort(s); parameter param(r_sort); family_id fid = get_family_id(); expr_ref e(m.mk_fresh_const("T", r_sort), m); expr* args[1] = { e.get() }; func_decl_ref empty_decl(m.mk_func_decl(fid, OP_RA_EMPTY, 1, ¶m, 0, (sort*const*)0), m); reduce_assign(empty_decl, 0, 0, 1, args); return alloc(external_relation, *this, s, e); }
relation_mutator_fn * external_relation_plugin::mk_filter_equal_fn(const relation_base & r, const relation_element & value, unsigned col) { if(!check_kind(r)) { return 0; } ast_manager& m = get_ast_manager(); app_ref condition(m); expr_ref var(m); sort* relation_sort = get(r).get_sort(); sort* column_sort = get_column_sort(col, relation_sort); var = m.mk_var(col, column_sort); condition = m.mk_eq(var, value); return mk_filter_interpreted_fn(r, condition); }
bool udoc_plugin::is_numeral(expr* e, rational& r, unsigned& num_bits) { if (bv.is_numeral(e, r, num_bits)) return true; if (m.is_true(e)) { r = rational(1); num_bits = 1; return true; } if (m.is_false(e)) { r = rational(0); num_bits = 1; return true; } uint64 n, sz; ast_manager& m = get_ast_manager(); if (dl.is_numeral(e, n) && dl.try_get_size(m.get_sort(e), sz)) { num_bits = 0; while (sz > 0) ++num_bits, sz = sz/2; r = rational(n, rational::ui64()); return true; } return false; }
interval_relation_plugin::interval_relation_plugin(relation_manager& m): relation_plugin(interval_relation_plugin::get_name(), m), m_empty(m_dep), m_arith(get_ast_manager()) { }
bound_relation_plugin::bound_relation_plugin(relation_manager& m): relation_plugin(bound_relation_plugin::get_name(), m), m_arith(get_ast_manager()), m_bsimp(get_ast_manager()) { }
void external_relation_plugin::mk_filter_fn(sort* s, app* condition, func_decl_ref& f) { ast_manager& m = get_ast_manager(); family_id fid = get_family_id(); parameter param(condition); f = m.mk_func_decl(fid, OP_RA_FILTER, 1, ¶m, 1, &s); }