box random_icp::solve(box b, double const precision ) { thread_local static unordered_set<shared_ptr<constraint>> used_constraints; used_constraints.clear(); thread_local static vector<box> solns; thread_local static vector<box> box_stack; solns.clear(); box_stack.clear(); box_stack.push_back(b); do { DREAL_LOG_INFO << "random_icp::solve - loop" << "\t" << "box stack Size = " << box_stack.size(); b = box_stack.back(); box_stack.pop_back(); try { m_ctc.prune(b, m_config); auto this_used_constraints = m_ctc.used_constraints(); used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end()); } catch (contractor_exception & e) { // Do nothing } if (!b.is_empty()) { tuple<int, box, box> splits = b.bisect(precision); int const i = get<0>(splits); if (i >= 0) { box const & first = get<1>(splits); box const & second = get<2>(splits); if (random_bool()) { box_stack.push_back(second); box_stack.push_back(first); } else { box_stack.push_back(first); box_stack.push_back(second); } if (m_config.nra_proof) { m_config.nra_proof_out << "[branched on " << b.get_name(i) << "]" << endl; } } else { m_config.nra_found_soln++; if (m_config.nra_found_soln >= m_config.nra_multiple_soln) { break; } if (m_config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, m_config, m_config.nra_found_soln); } solns.push_back(b); } } } while (box_stack.size() > 0); m_ctc.set_used_constraints(used_constraints); if (m_config.nra_multiple_soln > 1 && solns.size() > 0) { return solns.back(); } else { assert(!b.is_empty() || box_stack.size() == 0); return b; } }
box naive_icp::solve(box b, contractor & ctc, scoped_vec<shared_ptr<constraint>> const & ctrs, SMTConfig & config, BranchHeuristic& brancher) { thread_local static unordered_set<shared_ptr<constraint>> used_constraints; used_constraints.clear(); thread_local static vector<box> solns; thread_local static vector<box> box_stack; solns.clear(); box_stack.clear(); box_stack.push_back(b); do { DREAL_LOG_INFO << "naive_icp::solve - loop" << "\t" << "box stack Size = " << box_stack.size(); b = box_stack.back(); box_stack.pop_back(); prune(b, ctc, config, used_constraints); if (!b.is_empty()) { if (config.nra_use_stat) { config.nra_stat.increase_branch(); } vector<int> sorted_dims = brancher.sort_branches(b, ctrs, config); if (sorted_dims.size() > 0) { int const i = sorted_dims[0]; tuple<int, box, box> splits = b.bisect_at(sorted_dims[0]); box const & first = get<1>(splits); box const & second = get<2>(splits); assert(first.get_idx_last_branched() == i); assert(second.get_idx_last_branched() == i); if (second.is_bisectable()) { box_stack.push_back(second); box_stack.push_back(first); } else { box_stack.push_back(first); box_stack.push_back(second); } if (config.nra_proof) { config.nra_proof_out << "[branched on " << b.get_name(i) << "]" << endl; } } else { config.nra_found_soln++; if (config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, config, config.nra_found_soln); } if (config.nra_found_soln >= config.nra_multiple_soln) { break; } solns.push_back(b); } } } while (box_stack.size() > 0); ctc.set_used_constraints(used_constraints); if (config.nra_multiple_soln > 1 && solns.size() > 0) { return solns.back(); } else { assert(!b.is_empty() || box_stack.size() == 0); return b; } }
box naive_icp::solve(box b, contractor const & ctc, SMTConfig & config) { vector<box> solns; vector<box> box_stack; box_stack.push_back(b); do { DREAL_LOG_INFO << "icp_loop()" << "\t" << "box stack Size = " << box_stack.size(); b = box_stack.back(); box_stack.pop_back(); try { b = ctc.prune(b, config); if (config.nra_use_stat) { config.nra_stat.increase_prune(); } } catch (contractor_exception & e) { // Do nothing } if (!b.is_empty()) { tuple<int, box, box> splits = b.bisect(config.nra_precision); if (config.nra_use_stat) { config.nra_stat.increase_branch(); } int const i = get<0>(splits); if (i >= 0) { box const & first = get<1>(splits); box const & second = get<2>(splits); if (second.is_bisectable()) { box_stack.push_back(second); box_stack.push_back(first); } else { box_stack.push_back(first); box_stack.push_back(second); } if (config.nra_proof) { config.nra_proof_out << "[branched on " << b.get_name(i) << "]" << endl; } } else { config.nra_found_soln++; if (config.nra_found_soln >= config.nra_multiple_soln) { break; } if (config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, config, config.nra_found_soln); } solns.push_back(b); } } } while (box_stack.size() > 0); if (config.nra_multiple_soln > 1 && solns.size() > 0) { return solns.back(); } else { assert(!b.is_empty() || box_stack.size() == 0); // cerr << "BEFORE ADJUST_BOUND\n==================\n" << b << "=========================\n\n\n"; b.adjust_bound(box_stack); // cerr << "AFTER ADJUST_BOUND\n==================\n" << b << "=========================\n\n\n"; return b; } }
box multiheuristic_icp::solve(box bx, contractor & ctc, scoped_vec<shared_ptr<constraint>> const & ctrs, SMTConfig & config, vector<reference_wrapper<BranchHeuristic>> heuristics) { // don't use yet, since contractor is not yet threadsafe static vector<box> solns; solns.clear(); mutex mu; box hull = bx; // hull is a shared box, that's used by all dothreads, // contains the intersection of the unions of the possible regions for each heuristic. // Therefore, any solution must be in hull. atomic_bool solved; unordered_set<shared_ptr<constraint>> all_used_constraints; prune(hull, ctc, config, all_used_constraints); vector<thread> threads; auto dothread = [&](BranchHeuristic & heuristic) { #define PRUNEBOX(x) prune((x), ctc, config, used_constraints) thread_local static unordered_set<shared_ptr<constraint>> used_constraints; thread_local static vector<box> box_stack; thread_local static vector<box> hull_stack; // nth box in hull_stack contains hull of first n boxes in box_stack box_stack.clear(); hull_stack.clear(); used_constraints.clear(); auto pushbox = [&](box b) { box_stack.push_back(b); // copies hull into vector if (hull_stack.size() > 0) { b.hull(hull_stack.back()); } // maintain hull_stack invariant hull_stack.push_back(b); }; auto popbox = [&] { box b = box_stack.back(); box_stack.pop_back(); hull_stack.pop_back(); return b; }; mu.lock(); box b = hull; mu.unlock(); pushbox(b); do { b = popbox(); mu.lock(); b.intersect(hull); // TODO(clhuang): is contractor threadsafe??? PRUNEBOX(b); mu.unlock(); if (!b.is_empty()) { vector<int> sorted_dims = heuristic.sort_branches(b, ctrs, config); if (config.nra_use_stat) { config.nra_stat.increase_branch(); } if (sorted_dims.size() > 0) { int bisectdim = sorted_dims[0]; auto splits = b.bisect_at(bisectdim); box first = get<1>(splits); box second = get<2>(splits); assert(bisectdim != -1); assert(first.get_idx_last_branched() == bisectdim); assert(second.get_idx_last_branched() == bisectdim); if (second.is_bisectable()) { pushbox(second); pushbox(first); } else { pushbox(first); pushbox(second); } if (config.nra_proof) { config.nra_proof_out << "[branched on " << b.get_name(bisectdim) << "]" << endl; } } else { mu.lock(); config.nra_found_soln++; solns.push_back(b); if (config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, config, config.nra_found_soln); } if (config.nra_found_soln >= config.nra_multiple_soln) { solved = true; mu.unlock(); break; } mu.unlock(); } } // hull_stack, hopefully shrunk if (!hull_stack.empty()) { mu.lock(); hull.intersect(hull_stack.back()); mu.unlock(); } } while (box_stack.size() > 0 && !solved); mu.lock(); if (config.nra_found_soln == 0) { solved = true; // needed if unsat solns.push_back(b); // would be empty } // update all_used_constraints for (auto x : used_constraints) { all_used_constraints.insert(x); } mu.unlock(); #undef PRUNEBOX }; for (auto& heuristic : heuristics) { threads.push_back(thread(dothread, heuristic)); } for (auto& t : threads) { t.join(); } ctc.set_used_constraints(all_used_constraints); return solns.back(); }
box multiprune_icp::solve(box b, contractor & ctc, scoped_vec<shared_ptr<constraint>> const & ctrs, SMTConfig & config, BranchHeuristic& brancher, unsigned num_try) { #define PRUNEBOX(x) prune((x), ctc, config, used_constraints) thread_local static unordered_set<shared_ptr<constraint>> used_constraints; used_constraints.clear(); thread_local static vector<box> solns; thread_local static vector<box> box_stack; solns.clear(); box_stack.clear(); PRUNEBOX(b); box_stack.push_back(b); do { DREAL_LOG_INFO << "multiprune_icp::solve - loop" << "\t" << "box stack Size = " << box_stack.size(); b = box_stack.back(); box_stack.pop_back(); if (!b.is_empty()) { vector<int> sorted_dims = brancher.sort_branches(b, ctrs, config); if (sorted_dims.size() > num_try) { sorted_dims = vector<int>(sorted_dims.begin(), sorted_dims.begin()+num_try); } if (config.nra_use_stat) { config.nra_stat.increase_branch(); } if (sorted_dims.size() > 0) { int bisectdim = -1; box first = b; box second = b; double score = -INFINITY; for (int dim : sorted_dims) { tuple<int, box, box> splits = b.bisect_at(dim); box a1 = get<1>(splits); box a2 = get<2>(splits); PRUNEBOX(a1); PRUNEBOX(a2); double cscore = -a1.volume() * a2.volume(); if (cscore > score || bisectdim == -1) { first.hull(second); a1.intersect(first); a2.intersect(first); first = a1; second = a2; bisectdim = dim; score = cscore; } else { a1.hull(a2); first.intersect(a1); second.intersect(a1); } } assert(bisectdim != -1); assert(first.get_idx_last_branched() == bisectdim); assert(second.get_idx_last_branched() == bisectdim); if (second.is_bisectable()) { box_stack.push_back(second); box_stack.push_back(first); } else { box_stack.push_back(first); box_stack.push_back(second); } if (config.nra_proof) { config.nra_proof_out << "[branched on " << b.get_name(bisectdim) << "]" << endl; } } else { config.nra_found_soln++; if (config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, config, config.nra_found_soln); } if (config.nra_found_soln >= config.nra_multiple_soln) { break; } solns.push_back(b); } } } while (box_stack.size() > 0); ctc.set_used_constraints(used_constraints); if (config.nra_multiple_soln > 1 && solns.size() > 0) { return solns.back(); } else { assert(!b.is_empty() || box_stack.size() == 0); return b; } #undef PRUNEBOX }
box naive_icp::solve(box b, contractor & ctc, SMTConfig & config) { thread_local static std::unordered_set<std::shared_ptr<constraint>> used_constraints; used_constraints.clear(); thread_local static vector<box> solns; thread_local static vector<box> box_stack; solns.clear(); box_stack.clear(); box_stack.push_back(b); do { DREAL_LOG_INFO << "naive_icp::solve - loop" << "\t" << "box stack Size = " << box_stack.size(); b = box_stack.back(); box_stack.pop_back(); try { ctc.prune(b, config); auto this_used_constraints = ctc.used_constraints(); used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end()); if (config.nra_use_stat) { config.nra_stat.increase_prune(); } } catch (contractor_exception & e) { // Do nothing } if (!b.is_empty()) { tuple<int, box, box> splits = b.bisect(config.nra_precision); if (config.nra_use_stat) { config.nra_stat.increase_branch(); } int const i = get<0>(splits); if (i >= 0) { box const & first = get<1>(splits); box const & second = get<2>(splits); assert(first.get_idx_last_branched() == i); assert(second.get_idx_last_branched() == i); if (second.is_bisectable()) { box_stack.push_back(second); box_stack.push_back(first); } else { box_stack.push_back(first); box_stack.push_back(second); } if (config.nra_proof) { config.nra_proof_out << "[branched on " << b.get_name(i) << "]" << endl; } } else { config.nra_found_soln++; if (config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, config, config.nra_found_soln); } if (config.nra_found_soln >= config.nra_multiple_soln) { break; } solns.push_back(b); } } } while (box_stack.size() > 0); ctc.set_used_constraints(used_constraints); if (config.nra_multiple_soln > 1 && solns.size() > 0) { return solns.back(); } else { assert(!b.is_empty() || box_stack.size() == 0); return b; } }
box sample_icp::solve(box init_b, contractor const & ctc, SMTConfig & config ) { vector<box> solns; vector<box> box_stack; box b = init_b; box_stack.push_back(b); std::map<unsigned int, unsigned int> nempty; // Number of empty boxes at particular depth int nconflicts = 0; // Random Restarts // I need a container for my stack that will allow me to add elements to the end, // i.e lower depth means its at the end and pop from either end // std::set<box, BoxComparator> box_stack; do { DREAL_LOG_INFO << "icp_loop()" << "\t" << "box stack Size = " << box_stack.size(); b = box_stack.back(); box_stack.pop_back(); // std::cout << "Depth: " << b.depth << std::endl; try { b = ctc.prune(b, config); } catch (contractor_exception & e) { // Do nothing } if (!b.is_empty()) { tuple<int, box, box> splits = b.bisect(config.nra_precision); int const i = get<0>(splits); // std::cout << "i is" << i << std::endl; if (i >= 0) { box & first = get<1>(splits); box & second = get<2>(splits); first.depth = b.depth + 1; second.depth = b.depth + 1; bool leftright = random_icp::random_bool(); // std::cout << "left or right? " << leftright << std::endl; if (leftright) { box_stack.push_back(second); box_stack.push_back(first); } else { box_stack.push_back(first); box_stack.push_back(second); } if (config.nra_proof) { config.nra_proof_out << "[branched on " << b.get_name(i) << "]" << endl; } } else { config.nra_found_soln++; if (config.nra_found_soln >= config.nra_multiple_soln) { break; } if (config.nra_multiple_soln > 1) { // If --multiple_soln is used output_solution(b, config, config.nra_found_soln); } solns.push_back(b); } } else { // std::cout << "Backtracking at Depth: " << b.depth << std::endl; nempty[b.depth] += 1; nconflicts += 1; int nconflicts_before_restart = 200; if (nconflicts > nconflicts_before_restart) { std::cout << "Restarting" << std::endl; box_stack.empty(); box_stack.push_back(init_b); nempty.empty(); nconflicts = 0; continue; } } } while (box_stack.size() > 0); if (config.nra_multiple_soln > 1 && solns.size() > 0) { return solns.back(); } else { assert(!b.is_empty() || box_stack.size() == 0); // cerr << "BEFORE ADJUST_BOUND\n==================\n" << b << "=========================\n\n\n"; b.adjust_bound(box_stack); // cerr << "AFTER ADJUST_BOUND\n==================\n" << b << "=========================\n\n\n"; double q = proposal_prob(b.depth, nempty); b.logprob = q; return b; } }