bool sat_path_enumeratort::next(patht &path) { scratch_programt program(symbol_table); program.append(fixed); program.append(fixed); // Let's make sure that we get a path we have not seen before. for(std::list<distinguish_valuest>::iterator it=accelerated_paths.begin(); it!=accelerated_paths.end(); ++it) { exprt new_path=false_exprt(); for(distinguish_valuest::iterator jt=it->begin(); jt!=it->end(); ++jt) { exprt distinguisher=jt->first; bool taken=jt->second; if(taken) { not_exprt negated(distinguisher); distinguisher.swap(negated); } or_exprt disjunct(new_path, distinguisher); new_path.swap(disjunct); } program.assume(new_path); } program.add_instruction(ASSERT)->guard=false_exprt(); try { if(program.check_sat()) { #ifdef DEBUG std::cout << "Found a path" << std::endl; #endif build_path(program, path); record_path(program); return true; } } catch(std::string s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } catch(const char *s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } return false; }
void RectangularMatrixTest::negative() { Matrix2 matrix(Vector2(1.0f, -3.0f), Vector2(5.0f, -10.0f)); Matrix2 negated(Vector2(-1.0f, 3.0f), Vector2(-5.0f, 10.0f)); CORRADE_COMPARE(-matrix, negated); }
static void dump_ex(const typename char_state_machine::dfa &dfa_, ostream &stream_) { const std::size_t states_ = dfa_._states.size(); const id_type bol_index_ = dfa_._bol_index; typename dfa_state::id_type_string_token_map::const_iterator iter_; typename dfa_state::id_type_string_token_map::const_iterator end_; for (std::size_t i_ = 0; i_ < states_; ++i_) { const dfa_state &state_ = dfa_._states[i_]; state(stream_); stream_ << i_ << std::endl; if (state_._end_state) { end_state(stream_); if (state_._push_pop_dfa == dfa_state::push_dfa) { push(stream_); stream_ << state_._push_dfa; } else if (state_._push_pop_dfa == dfa_state::pop_dfa) { pop(stream_); } id(stream_); stream_ << static_cast<std::size_t>(state_._id); user_id(stream_); stream_ << static_cast<std::size_t>(state_._user_id); dfa(stream_); stream_ << static_cast<std::size_t>(state_._next_dfa); stream_ << std::endl; } if (i_ == 0 && bol_index_ != char_state_machine::npos()) { bol(stream_); stream_ << static_cast<std::size_t>(bol_index_) << std::endl; } if (state_._eol_index != char_state_machine::npos()) { eol(stream_); stream_ << static_cast<std::size_t>(state_._eol_index) << std::endl; } iter_ = state_._transitions.begin(); end_ = state_._transitions.end(); for (; iter_ != end_; ++iter_) { string_token token_ = iter_->second; open_bracket(stream_); if (!iter_->second.any() && iter_->second.negatable()) { token_.negate(); negated(stream_); } string chars_; typename string_token::range_vector::const_iterator ranges_iter_ = token_._ranges.begin(); typename string_token::range_vector::const_iterator ranges_end_ = token_._ranges.end(); for (; ranges_iter_ != ranges_end_; ++ranges_iter_) { if (ranges_iter_->first == '-' || ranges_iter_->first == '^' || ranges_iter_->first == ']') { stream_ << '\\'; } chars_ = string_token::escape_char (ranges_iter_->first); if (ranges_iter_->first != ranges_iter_->second) { if (ranges_iter_->first + 1 < ranges_iter_->second) { chars_ += '-'; } if (ranges_iter_->second == '-' || ranges_iter_->second == '^' || ranges_iter_->second == ']') { stream_ << '\\'; } chars_ += string_token::escape_char (ranges_iter_->second); } stream_ << chars_; } close_bracket(stream_); stream_ << static_cast<std::size_t>(iter_->first) << std::endl; } stream_ << std::endl; } }
bool disjunctive_polynomial_accelerationt::fit_polynomial( exprt &var, polynomialt &polynomial, patht &path) { // These are the variables that var depends on with respect to the body. std::vector<expr_listt> parameters; std::set<std::pair<expr_listt, exprt> > coefficients; expr_listt exprs; scratch_programt program(symbol_table); expr_sett influence; cone_of_influence(var, influence); #ifdef DEBUG std::cout << "Fitting a polynomial for " << expr2c(var, ns) << ", which depends on:" << std::endl; for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { std::cout << expr2c(*it, ns) << std::endl; } #endif for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { if (it->id() == ID_index || it->id() == ID_dereference) { // Hack: don't accelerate anything that depends on an array // yet... return false; } exprs.clear(); exprs.push_back(*it); parameters.push_back(exprs); exprs.push_back(loop_counter); parameters.push_back(exprs); } // N exprs.clear(); exprs.push_back(loop_counter); parameters.push_back(exprs); // N^2 exprs.push_back(loop_counter); parameters.push_back(exprs); // Constant exprs.clear(); parameters.push_back(exprs); for (std::vector<expr_listt>::iterator it = parameters.begin(); it != parameters.end(); ++it) { symbolt coeff = utils.fresh_symbol("polynomial::coeff", signed_poly_type()); coefficients.insert(make_pair(*it, coeff.symbol_expr())); // XXX HACK HACK HACK // I'm just constraining these coefficients to prevent overflows messing things // up later... Should really do this properly somehow. program.assume(binary_relation_exprt(from_integer(-(1 << 10), signed_poly_type()), "<", coeff.symbol_expr())); program.assume(binary_relation_exprt(coeff.symbol_expr(), "<", from_integer(1 << 10, signed_poly_type()))); } // Build a set of values for all the parameters that allow us to fit a // unique polynomial. std::map<exprt, exprt> ivals1; std::map<exprt, exprt> ivals2; std::map<exprt, exprt> ivals3; for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { symbolt ival1 = utils.fresh_symbol("polynomial::init", it->type()); symbolt ival2 = utils.fresh_symbol("polynomial::init", it->type()); symbolt ival3 = utils.fresh_symbol("polynomial::init", it->type()); program.assume(binary_relation_exprt(ival1.symbol_expr(), "<", ival2.symbol_expr())); program.assume(binary_relation_exprt(ival2.symbol_expr(), "<", ival3.symbol_expr())); #if 0 if (it->type() == signedbv_typet()) { program.assume(binary_relation_exprt(ival1.symbol_expr(), ">", from_integer(-100, it->type()))); } program.assume(binary_relation_exprt(ival1.symbol_expr(), "<", from_integer(100, it->type()))); if (it->type() == signedbv_typet()) { program.assume(binary_relation_exprt(ival2.symbol_expr(), ">", from_integer(-100, it->type()))); } program.assume(binary_relation_exprt(ival2.symbol_expr(), "<", from_integer(100, it->type()))); if (it->type() == signedbv_typet()) { program.assume(binary_relation_exprt(ival3.symbol_expr(), ">", from_integer(-100, it->type()))); } program.assume(binary_relation_exprt(ival3.symbol_expr(), "<", from_integer(100, it->type()))); #endif ivals1[*it] = ival1.symbol_expr(); ivals2[*it] = ival2.symbol_expr(); ivals3[*it] = ival3.symbol_expr(); //ivals1[*it] = from_integer(1, it->type()); } std::map<exprt, exprt> values; for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { values[*it] = ivals1[*it]; } // Start building the program. Begin by decl'ing each of the // master distinguishers. for (std::list<exprt>::iterator it = distinguishers.begin(); it != distinguishers.end(); ++it) { program.add_instruction(DECL)->code = code_declt(*it); } // Now assume our polynomial fits at each of our sample points. assert_for_values(program, values, coefficients, 1, fixed, var); for (int n = 0; n <= 1; n++) { for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { values[*it] = ivals2[*it]; assert_for_values(program, values, coefficients, n, fixed, var); values[*it] = ivals3[*it]; assert_for_values(program, values, coefficients, n, fixed, var); values[*it] = ivals1[*it]; } } for (expr_sett::iterator it = influence.begin(); it != influence.end(); ++it) { values[*it] = ivals3[*it]; } assert_for_values(program, values, coefficients, 0, fixed, var); assert_for_values(program, values, coefficients, 1, fixed, var); assert_for_values(program, values, coefficients, 2, fixed, var); // Let's make sure that we get a path we have not seen before. for (std::list<distinguish_valuest>::iterator it = accelerated_paths.begin(); it != accelerated_paths.end(); ++it) { exprt new_path = false_exprt(); for (distinguish_valuest::iterator jt = it->begin(); jt != it->end(); ++jt) { exprt distinguisher = jt->first; bool taken = jt->second; if (taken) { not_exprt negated(distinguisher); distinguisher.swap(negated); } or_exprt disjunct(new_path, distinguisher); new_path.swap(disjunct); } program.assume(new_path); } utils.ensure_no_overflows(program); // Now do an ASSERT(false) to grab a counterexample program.add_instruction(ASSERT)->guard = false_exprt(); // If the path is satisfiable, we've fitted a polynomial. Extract the // relevant coefficients and return the expression. try { if (program.check_sat()) { #ifdef DEBUG std::cout << "Found a polynomial" << std::endl; #endif utils.extract_polynomial(program, coefficients, polynomial); build_path(program, path); record_path(program); return true; } } catch (std::string s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } catch (const char *s) { std::cout << "Error in fitting polynomial SAT check: " << s << std::endl; } return false; }
static void dump (const basic_state_machine<CharT> &state_machine_, ostream &stream_) { typename basic_state_machine<CharT>::iterator iter_ = state_machine_.begin (); typename basic_state_machine<CharT>::iterator end_ = state_machine_.end (); for (std::size_t dfa_ = 0, dfas_ = state_machine_.size (); dfa_ < dfas_; ++dfa_) { const std::size_t states_ = iter_->states; for (std::size_t i_ = 0; i_ < states_; ++i_) { state (stream_); stream_ << i_ << std::endl; if (iter_->end_state) { end_state (stream_); stream_ << iter_->id; dfa (stream_); stream_ << iter_->goto_dfa; stream_ << std::endl; } if (iter_->bol_index != npos) { bol (stream_); stream_ << iter_->bol_index << std::endl; } if (iter_->eol_index != npos) { eol (stream_); stream_ << iter_->eol_index << std::endl; } const std::size_t transitions_ = iter_->transitions; if (transitions_ == 0) { ++iter_; } for (std::size_t t_ = 0; t_ < transitions_; ++t_) { std::size_t goto_state_ = iter_->goto_state; if (iter_->token.any ()) { any (stream_); } else { open_bracket (stream_); if (iter_->token._negated) { negated (stream_); } string charset_; CharT c_ = 0; escape_control_chars (iter_->token._charset, charset_); c_ = *charset_.c_str (); if (!iter_->token._negated && (c_ == '^' || c_ == ']')) { stream_ << '\\'; } stream_ << charset_; close_bracket (stream_); } stream_ << goto_state_ << std::endl; ++iter_; } stream_ << std::endl; } } }
// Internal function actually performing the work of dumping the // state machine in DOT. static void dump_ex ( id_type dfa_id_, const typename char_state_machine::dfa &dfa_, rules &rules_, ostream &stream_) { const std::size_t states_ = dfa_._states.size (); typename dfa_state::id_type_string_token_map::const_iterator iter_; typename dfa_state::id_type_string_token_map::const_iterator end_; stream_ << std::endl; for (std::size_t i_ = 0; i_ < states_; ++i_) { const dfa_state &state_ = dfa_._states[i_]; const string name = node_name(dfa_id_, i_); if (i_ == 0) { stream_ << " " << name << " [shape = doublecircle, xlabel=\"" << rules_.state(dfa_id_) << "\"];" << std::endl; } else if (state_._end_state) { stream_ << " " << name << " [shape = doublecircle, xlabel=\"id =" << static_cast<std::size_t>(state_._id) << "\"];" << std::endl; } else { stream_ << " " << name << " [shape = circle];" << std::endl; } } stream_ << std::endl; for (std::size_t i_ = 0; i_ < states_; ++i_) { const dfa_state &state_ = dfa_._states[i_]; iter_ = state_._transitions.begin (); end_ = state_._transitions.end (); const string src_name = node_name(dfa_id_, i_); for (; iter_ != end_; ++iter_) { const string dst_name = node_name(dfa_id_, iter_->first); stream_ << " " << src_name << " -> " << dst_name << " [label = \""; string_token token_ = iter_->second; open_bracket (stream_); if (!iter_->second.any () && iter_->second.negatable ()) { token_.negate (); negated (stream_); } string chars_; typename string_token::range_vector::const_iterator ranges_iter_ = token_._ranges.begin (); typename string_token::range_vector::const_iterator ranges_end_ = token_._ranges.end (); for (; ranges_iter_ != ranges_end_; ++ranges_iter_) { if (ranges_iter_->first == '^' || ranges_iter_->first == ']') { stream_ << "\\\\"; } chars_ = double_escape_char(ranges_iter_->first); if (ranges_iter_->first != ranges_iter_->second) { if (ranges_iter_->first + 1 < ranges_iter_->second) { chars_ += '-'; } if (ranges_iter_->second == '^' || ranges_iter_->second == ']') { stream_ << "\\\\"; } chars_ += double_escape_char(ranges_iter_->second); } stream_ << chars_; } close_bracket (stream_); stream_ << "\"];" << std::endl; } if (state_._end_state) { const string dst_name = node_name(state_._next_dfa, 0); stream_ << " " << src_name << " -> " << dst_name << " [style = \"dashed\"];" << std::endl; } } }