bool context::scoped_state::set(ptr_vector<expr> & hard) { bool eq = hard.size() == m_hard.size(); for (unsigned i = 0; eq && i < hard.size(); ++i) { eq = hard[i] == m_hard[i].get(); } m_hard.reset(); m_hard.append(hard.size(), hard.c_ptr()); return !eq; }
static void show_interpolant_and_maybe_check(cmd_context & ctx, ptr_vector<ast> &cnsts, expr *t, ptr_vector<ast> &interps, params_ref &m_params, bool check) { if (m_params.get_bool("som", false)) m_params.set_bool("flat", true); th_rewriter s(ctx.m(), m_params); for(unsigned i = 0; i < interps.size(); i++){ expr_ref r(ctx.m()); proof_ref pr(ctx.m()); s(to_expr(interps[i]),r,pr); ctx.regular_stream() << mk_pp(r.get(), ctx.m()) << std::endl; #if 0 ast_smt_pp pp(ctx.m()); pp.set_logic(ctx.get_logic().str().c_str()); pp.display_smt2(ctx.regular_stream(), to_expr(interps[i])); ctx.regular_stream() << std::endl; #endif } s.cleanup(); // verify, for the paranoid... if(check || interp_params(m_params).check()){ std::ostringstream err; ast_manager &_m = ctx.m(); // need a solver -- make one here FIXME is this right? bool proofs_enabled, models_enabled, unsat_core_enabled; params_ref p; ctx.params().get_solver_params(_m, p, proofs_enabled, models_enabled, unsat_core_enabled); scoped_ptr<solver> sp = (ctx.get_solver_factory())(_m, p, false, true, false, ctx.get_logic()); if(iz3check(_m,sp.get(),err,cnsts,t,interps)) ctx.regular_stream() << "correct\n"; else ctx.regular_stream() << "incorrect: " << err.str().c_str() << "\n"; } for(unsigned i = 0; i < interps.size(); i++){ ctx.m().dec_ref(interps[i]); } interp_params itp_params(m_params); if(itp_params.profile()) profiling::print(ctx.regular_stream()); }
/** Write settings to config file. */ void UserConfig::saveConfig() { const std::string dir = file_manager->getConfigDir(); if(dir=="") { std::cerr << "User config firectory does not exist, cannot save config file!\n"; return; } const std::string filename = dir + "/" + m_filename; std::ofstream configfile; configfile.open (filename.c_str()); if(!configfile.is_open()) { std::cerr << "Failed to open " << filename.c_str() << " for writing, user config won't be saved\n"; return; } configfile << "<?xml version=\"1.0\"?>\n"; configfile << "<stkconfig version=\"" << CURRENT_CONFIG_VERSION << "\" >\n\n"; const int paramAmount = all_params.size(); for(int i=0; i<paramAmount; i++) { //std::cout << "saving parameter " << i << " to file\n"; all_params[i].write(configfile); } configfile << "</stkconfig>\n"; configfile.close(); } // saveConfig
// store equivalence class in VertexInfo for each vertex static vector<VertexInfoSet> partitionGraph(ptr_vector<VertexInfo> &infos, WorkQueue &work_queue, const NGHolder &g, EquivalenceType eq) { const size_t num_verts = infos.size(); vector<VertexInfoSet> classes; unordered_map<ClassInfo, unsigned> classinfomap; // assume we will have lots of classes, so we don't waste time resizing // these structures. classes.reserve(num_verts); classinfomap.reserve(num_verts); // get distances from start (or accept) for all vertices // only one of them is used at a time, never both vector<NFAVertexDepth> depths; vector<NFAVertexRevDepth> rdepths; if (eq == LEFT_EQUIVALENCE) { calcDepths(g, depths); } else { calcDepths(g, rdepths); } // partition the graph based on CharReach for (VertexInfo &vi : infos) { ClassInfo::ClassDepth depth; if (eq == LEFT_EQUIVALENCE) { depth = depths[vi.vert_index]; } else { depth = rdepths[vi.vert_index]; } ClassInfo ci(g, vi, depth, eq); auto ii = classinfomap.find(ci); if (ii == classinfomap.end()) { // vertex is in a new equivalence class by itself. unsigned eq_class = classes.size(); vi.equivalence_class = eq_class; classes.push_back({&vi}); classinfomap.emplace(move(ci), eq_class); } else { // vertex is added to an existing class. unsigned eq_class = ii->second; vi.equivalence_class = eq_class; classes.at(eq_class).insert(&vi); // we now know that this particular class has more than one // vertex, so we add it to the work queue work_queue.push(eq_class); } } DEBUG_PRINTF("partitioned, %zu equivalence classes\n", classes.size()); return classes; }
bool is_well_formed_vars(ptr_vector<sort>& bound, expr* e) { ptr_vector<expr> todo; ast_mark mark; todo.push_back(e); while (!todo.empty()) { expr* e = todo.back(); todo.pop_back(); if (mark.is_marked(e)) { continue; } mark.mark(e, true); if (is_quantifier(e)) { quantifier* q = to_quantifier(e); unsigned depth = q->get_num_decls(); bound.append(depth, q->get_decl_sorts()); if (!is_well_formed_vars(bound, q->get_expr())) { return false; } bound.resize(bound.size()-depth); } else if (is_app(e)) { app* a = to_app(e); for (unsigned i = 0; i < a->get_num_args(); ++i) { todo.push_back(a->get_arg(i)); } } else if (is_var(e)) { var* v = to_var(e); unsigned index = v->get_idx(); sort* s = v->get_sort(); SASSERT(index < bound.size()); index = bound.size()-1-index; if (!bound[index]) { bound[index] = s; } if (bound[index] != s) { return false; } } else { UNREACHABLE(); } } return true; }
bool seq_decl_plugin::match(ptr_vector<sort>& binding, sort* s, sort* sP) { if (s == sP) return true; unsigned i; if (is_sort_param(sP, i)) { if (binding.size() <= i) binding.resize(i+1); if (binding[i] && (binding[i] != s)) return false; TRACE("seq_verbose", tout << "setting binding @ " << i << " to " << mk_pp(s, *m_manager) << "\n";); binding[i] = s; return true; }
bool symtable::find_overload(symbol s, ptr_vector<sort> const & dom, func_decl * & d) { ptr_vector<func_decl>* decls = 0; d = 0; if (!m_ids.find(s, decls)) { SASSERT(!decls); return false; } SASSERT(decls); for (unsigned i = 0; i < decls->size(); ++i) { func_decl* decl = (*decls)[i]; if (decl->is_associative() && decl->get_arity() > 0) { for (unsigned j = 0; j < dom.size(); ++j) { if (dom[j] != decl->get_domain(0)) { goto try_next; } } d = decl; return true; } if (decl->get_arity() != dom.size()) { goto try_next; } for (unsigned j = 0; j < decl->get_arity(); ++j) { if (decl->get_domain(j) != dom[j]) { goto try_next; } } d = decl; return true; try_next: if (decl->get_family_id() == m_manager.get_basic_family_id() && decl->get_decl_kind() == OP_DISTINCT) { // we skip type checking for 'distinct' d = decl; return true; } } return false; }
void itp_solver::undo_proxies_in_core (ptr_vector<expr> &r) { app_ref e(m); expr_fast_mark1 bg; for (unsigned i = 0; i < m_first_assumption; ++i) { bg.mark(m_assumptions.get(i)); } // expand proxies unsigned j = 0; for (unsigned i = 0, sz = r.size(); i < sz; ++i) { // skip background assumptions if (bg.is_marked(r[i])) { continue; } // -- undo proxies, but only if they were introduced in check_sat if (m_is_proxied && is_proxy(r[i], e)) { SASSERT (m.is_or (e)); r[j] = e->get_arg (1); } else if (i != j) { r[j] = r[i]; } j++; } r.shrink (j); }
void GOrgueMidiRtInPort::addMissingDevices(GOrgueMidi* midi, ptr_vector<GOrgueMidiInPort>& ports) { try { std::vector<RtMidi::Api> apis; RtMidi::getCompiledApi(apis); for(unsigned i = 0; i < apis.size(); i++) { try { RtMidiIn midi_dev(apis[i]); for (unsigned j = 0; j < midi_dev.getPortCount(); j++) { wxString name = GOrgueRtHelpers::GetMidiApiPrefix(apis[i]) + wxString::FromAscii(midi_dev.getPortName(j).c_str()); bool found = false; for(unsigned k = 0; k < ports.size(); k++) if (ports[k] && ports[k]->GetName() == name) found = true; if (!found) ports.push_back(new GOrgueMidiRtInPort(midi, GOrgueRtHelpers::GetMidiApiPrefix(apis[i]), name, apis[i])); } } catch (RtMidiError &e) { wxString error = wxString::FromAscii(e.getMessage().c_str()); wxLogError(_("RtMidi error: %s"), error.c_str()); } } } catch (RtMidiError &e) { wxString error = wxString::FromAscii(e.getMessage().c_str()); wxLogError(_("RtMidi error: %s"), error.c_str()); } }
#include "Util/CK/CK.h" #include <boost/ptr_container/ptr_vector.hpp> using boost::ptr_vector; #include <boost/shared_ptr.hpp> using boost::shared_ptr; #include "Util/CDCA_Tracer/CDCA_Tracer.h" using namespace std; int main() { CK_section( "Pointer container (vector) ..............." ) { ptr_vector<CDCA_Tracer> v; CK_compare( v.size() , 0 ) CDCA_Tracer *a[3]; const int N= sizeof a / sizeof a[0]; for (int i= 0; i < N; ++i) { v.push_back(a[i]= new CDCA_Tracer()); } CK_compare( CDCA_Tracer::getMessages() , "created <1>" "\n" "created <2>" "\n" "created <3>" "\n" ) CK_compare( v.size() , 3 ) CK_compare( &v.front() , a[0] ) CK_compare( &v.back() , a[2] ) CK_compare( typeid(v.back()) , typeid(CDCA_Tracer)) v.pop_back(); CK_compare( CDCA_Tracer::getMessages() ,
/** Load configuration values from file. */ bool UserConfig::loadConfig() { const std::string filename = file_manager->getConfigDir()+"/"+m_filename; XMLNode* root = file_manager->createXMLTree(filename); if(!root || root->getName() != "stkconfig") { std::cerr << "Could not read user config file file " << filename.c_str() << std::endl; if(root) delete root; return false; } // ---- Read config file version int configFileVersion = CURRENT_CONFIG_VERSION; if(root->get("version", &configFileVersion) < 1) { GUIEngine::showMessage( _("Your config file was malformed, so it was deleted and a new one will be created."), 10.0f); std::cerr << "Warning, malformed user config file! Contains no version\n"; } if (configFileVersion < CURRENT_CONFIG_VERSION) { // current version (8) is 100% incompatible with other versions (which were lisp) // so we just delete the old config. in the future, for smaller updates, we can // add back the code previously there that upgraded the config file to the new // format instead of overwriting it. GUIEngine::showMessage( _("Your config file was too old, so it was deleted and a new one will be created."), 10.0f); printf("Your config file was too old, so it was deleted and a new one will be created."); delete root; return false; } // if configFileVersion<SUPPORTED_CONFIG_VERSION // ---- Read parameters values (all parameter objects must have been created before this point if // you want them automatically read from the config file) const int paramAmount = all_params.size(); for(int i=0; i<paramAmount; i++) { all_params[i].findYourDataInAChildOf(root); } // ---- Read players // we create those AFTER other values are being read simply because we have many Player // nodes that all bear the same name, so the generic loading code won't work here UserConfigParams::m_all_players.clearAndDeleteAll(); std::vector<XMLNode*> players; root->getNodes("Player", players); const int amount = players.size(); for (int i=0; i<amount; i++) { //std::string name; //players[i]->get("name", &name); UserConfigParams::m_all_players.push_back( new PlayerProfile(players[i]) ); } // sort players by frequency of use std::sort (UserConfigParams::m_all_players.contentsVector.begin(), UserConfigParams::m_all_players.contentsVector.end(), comparePlayers); delete root; return true; } // loadConfig
void reduce(proof* pf, proof_ref &out) { proof *res = nullptr; m_todo.reset(); m_todo.push_back(pf); ptr_buffer<proof> args; bool dirty = false; while (!m_todo.empty()) { proof *p, *tmp, *pp; unsigned todo_sz; p = m_todo.back(); if (m_cache.find(p, tmp)) { res = tmp; m_todo.pop_back(); continue; } dirty = false; args.reset(); todo_sz = m_todo.size(); for (unsigned i = 0, sz = m.get_num_parents(p); i < sz; ++i) { pp = m.get_parent(p, i); if (m_cache.find(pp, tmp)) { args.push_back(tmp); dirty = dirty || pp != tmp; } else { m_todo.push_back(pp); } } if (todo_sz < m_todo.size()) { continue; } else { m_todo.pop_back(); } if (m.is_hypothesis(p)) { // hyp: replace by a corresponding unit if (m_units.find(m.get_fact(p), tmp)) { res = tmp; } else { res = p; } } else if (!dirty) { res = p; } else if (m.is_lemma(p)) { //lemma: reduce the premise; remove reduced consequences from conclusion SASSERT(args.size() == 1); res = mk_lemma_core(args.get(0), m.get_fact(p)); compute_mark1(res); } else if (m.is_unit_resolution(p)) { // unit: reduce units; reduce the first premise; rebuild unit resolution res = mk_unit_resolution_core(args.size(), args.c_ptr()); compute_mark1(res); } else { // other: reduce all premises; reapply if (m.has_fact(p)) { args.push_back(to_app(m.get_fact(p))); } SASSERT(p->get_decl()->get_arity() == args.size()); res = m.mk_app(p->get_decl(), args.size(), (expr * const*)args.c_ptr()); m_pinned.push_back(res); compute_mark1(res); } SASSERT(res); m_cache.insert(p, res); if (m.has_fact(res) && m.is_false(m.get_fact(res))) { break; } } out = res; }
tactic * translate(ast_manager & m) override { return alloc(sine_tactic, m, m_params); } void updt_params(params_ref const & p) override { } void collect_param_descrs(param_descrs & r) override { } void operator()(goal_ref const & g, goal_ref_buffer& result) override { TRACE("sine", g->display(tout);); TRACE("sine", tout << g->size();); ptr_vector<expr> new_forms; filter_expressions(g, new_forms); TRACE("sine", tout << new_forms.size();); g->reset(); for (unsigned i = 0; i < new_forms.size(); i++) { g->assert_expr(new_forms.get(i), 0, 0); } g->inc_depth(); g->updt_prec(goal::OVER); result.push_back(g.get()); TRACE("sine", result[0]->display(tout);); SASSERT(g->is_well_sorted()); } void cleanup() override { } private:
void iz3pp(ast_manager &m, const ptr_vector<expr> &cnsts_vec, expr *tree, std::ostream& out) { unsigned sz = cnsts_vec.size(); expr* const* cnsts = &cnsts_vec[0]; out << "(set-option :produce-interpolants true)\n"; free_func_visitor visitor(m); expr_mark visited; bool print_low_level = true; // m_params.print_low_level_smt2(); #define PP(_e_) if (print_low_level) out << mk_smt_pp(_e_, m); else ast_smt2_pp(out, _e_, env); smt2_pp_environment_dbg env(m); for (unsigned i = 0; i < sz; ++i) { expr* e = cnsts[i]; for_each_expr(visitor, visited, e); } // name all the constraints hash_map<expr *, symbol> cnames; int ctr = 1; for(unsigned i = 0; i < sz; i++){ symbol nm; std::ostringstream s; s << "f!" << (ctr++); cnames[cnsts[i]] = symbol(s.str().c_str()); } func_decl_set &funcs = visitor.funcs(); func_decl_set::iterator it = funcs.begin(), end = funcs.end(); obj_hashtable<class sort>& sorts = visitor.sorts(); obj_hashtable<class sort>::iterator sit = sorts.begin(), send = sorts.end(); for (; sit != send; ++sit) { PP(*sit); } for (; it != end; ++it) { func_decl* f = *it; if(f->get_family_id() == null_family_id){ PP(f); out << "\n"; } } for (unsigned i = 0; i < sz; ++i) { out << "(assert "; expr* r = cnsts[i]; symbol nm = cnames[r]; out << "(! "; PP(r); out << " :named "; if (is_smt2_quoted_symbol(nm)) { out << mk_smt2_quoted_symbol(nm); } else { out << nm; } out << ")"; out << ")\n"; } out << "(check-sat)\n"; out << "(get-interpolant "; iz3pp_helper pp(m); pp.print_tree(pp.cook(tree),cnames,out); out << ")\n"; }