bool PolygonElementParser::handlesElement(const NodeType::XMLNode& node) const
{
if (!typeIDSetInitialized) {
std::lock_guard<std::mutex> lock(polygonElementParser_initializedTypeIDMutex);
if(!typeIDSetInitialized) {
typeIDSet.insert(NodeType::GML_TriangleNode.typeID());
typeIDSet.insert(NodeType::GML_RectangleNode.typeID());
typeIDSet.insert(NodeType::GML_PolygonNode.typeID());
typeIDSet.insert(NodeType::GML_PolygonPatchNode.typeID());
typeIDSetInitialized = true;
}
}
return typeIDSet.count(node.typeID()) > 0;
}
bool should_rename(DexClass *clazz,
std::vector<std::string>& pre_patterns,
std::vector<std::string>& post_patterns,
std::unordered_set<const DexType*>& untouchables,
bool rename_annotations) {
if (!rename_annotations && is_annotation(clazz)) return false;
if (untouchables.count(clazz->get_type())) return false;
auto chstring = clazz->get_type()->get_name()->c_str();
/* We're assuming anonymous classes are safe always safe to rename. */
auto substr = strrchr(chstring, '$');
if (substr != nullptr) {
auto val = *++substr;
if (val >= '0' && val <= '9') {
match_inner++;
return true;
}
}
/* Check for more aggressive, but finer grained filters first */
for (auto p : pre_patterns) {
auto substr = strstr(chstring, p.c_str());
if (substr != nullptr) {
if (p.length() > 1) {
match_long++;
} else {
match_short++;
}
return true;
}
}
if (!can_rename(clazz) && !can_delete(clazz)) {
return false;
}
/* Check for wider, less precise filters */
for (auto p : post_patterns) {
auto substr = strstr(chstring, p.c_str());
if (substr != nullptr) {
if (p.length() > 1) {
match_long++;
} else {
match_short++;
}
return true;
}
}
return false;
}
void Regex::expandSpontaneous(std::unordered_set<std::size_t>& states) const {
std::queue<std::size_t> queue;
for (auto& state : states) {
queue.push(state);
}
while (!queue.empty()) {
std::size_t state = queue.front();
queue.pop();
for (std::size_t index : stateList[state].spontaneous) {
if (states.count(index) == 0) {
states.insert(index);
queue.push(index);
}
}
}
}
SparseArray3<Body>::Iterator GetBodyAt(Vec3i position) {
auto it = bodies.begin();
for(; it != bodies.end(); it++) {
if(!it->destroyable->alive) {
if(eatables.count(it.getHandle()))
eatables.erase(it.getHandle());
if(pushables.count(it.getHandle()))
pushables.erase(it.getHandle());
UnreferenceDestroyable(it->destroyable);
bodies.remove(it);
continue;
}
if(it->position == position)
return it;
}
return it;
}
double xrelevance(const MLNetworkSharedPtr& mnet, const ActorSharedPtr& actor, const std::unordered_set<LayerSharedPtr>& layers, edge_mode mode) {
set<actor_id> neighbors_on_selected_layers;
set<actor_id> neighbors_on_other_layers;
set<actor_id> all_neighbors;
for (NodeSharedPtr node: *mnet->get_nodes(actor)) {
for (NodeSharedPtr neighbor: *mnet->neighbors(node, mode)) {
all_neighbors.insert(neighbor->actor->id);
if (layers.count(neighbor->layer)>0)
neighbors_on_selected_layers.insert(neighbor->actor->id);
else neighbors_on_other_layers.insert(neighbor->actor->id);
}
}
if (all_neighbors.size()==0) return 0; // by definition
else {
for (actor_id actor: neighbors_on_other_layers)
neighbors_on_selected_layers.erase(actor);
return (double)neighbors_on_selected_layers.size()/all_neighbors.size();
}
}
bool PhpParam::defValNeedsVariable() const {
if (defVal.empty() || !isTypeCppIndirectPass(cppType)) {
return false;
}
if (cppType == "HPHP::String const&" && (defVal == "empty_string" ||
defVal == "null_string")) {
return false;
} else if (cppType == "HPHP::String const&" &&
g_knownStringConstants.count(defVal) > 0) {
return false;
} else if (cppType == "HPHP::Array const&" && defVal == "null_array") {
return false;
} else if (cppType == "HPHP::Object const&" && defVal == "null_object") {
return false;
} else if (cppType == "HPHP::Variant const&" && defVal == "null_variant") {
return false;
}
return true;
}
void Pedigree::addNode(std::unordered_set<OrganismSpecifier>& set, const OrganismSpecifier& newNode) {
// First check for exact match via hash-collision and equality
if (set.count(newNode) > 0) return;
// Now check for equality with something existing
for (auto& node : set) {
if (node == newNode) {
// See if the new node adds some more information and take this into account
if (node.name().empty() && !newNode.name().empty()) {
set.erase(node);
set.insert(newNode);
}
return;
}
}
// If nothing found then just insert the new node as given
set.insert(newNode);
}
size_t ExpiryTimerImpl::cancelAll(
const std::unordered_set< std::shared_ptr<TimerTask > >& tasks)
{
std::lock_guard< std::mutex > lock{ m_mutex };
size_t erased { 0 };
for(auto it = m_tasks.begin(); it != m_tasks.end();)
{
if(tasks.count(it->second))
{
it = m_tasks.erase(it);
++erased;
}
else
{
++it;
}
}
return erased;
}
void mesh::keep_faces(std::unordered_set<int> & to_keep, aiScene * s) {
aiMesh * mesh = s->mMeshes[0];
int num_new = 0;
aiFace * new_faces = new aiFace[mesh->mNumFaces];
// For each face in the mesh
for (int i = 0; i < mesh->mNumFaces; ++i) {
// If this face is in to_keep keep it
if (to_keep.count(i) > 0) {
new_faces[num_new] = mesh->mFaces[i];
++num_new;
}
}
delete[] mesh->mFaces;
mesh->mNumFaces = num_new;
mesh->mFaces = std::move(new_faces);
}
// Use DFS to detect a possible loop, most likely an loop in an irreducible
// CFG. One of the headers of the loop is the FirstBB.
// Loop is set to true upon successfully detecting such a loop.
void ExprBuilder::checkIrreducibleCFG(BasicBlock *BB,
BasicBlock *FirstBB,
std::unordered_set<const BasicBlock *> &VisitedBBs,
bool &Loop) {
VisitedBBs.insert(BB);
for (succ_iterator PI = succ_begin(BB), E = succ_end(BB);
PI != E; ++PI) {
BasicBlock *Succ = *PI;
if (Succ == FirstBB) {
Loop = true;
}
else if (VisitedBBs.count(Succ)) {
continue;
}
else {
checkIrreducibleCFG(Succ, FirstBB, VisitedBBs, Loop);
}
if (Loop)
return;
}
}
void mod_manager::load_mods_list(WORLDPTR world) const
{
if (world == NULL) {
return;
}
std::vector<std::string> &amo = world->active_mod_order;
amo.clear();
std::ifstream mods_list_file( get_mods_list_file(world).c_str(),
std::ios::in | std::ios::binary );
if (!mods_list_file) {
return;
}
bool obsolete_mod_found = false;
try {
JsonIn jsin(mods_list_file);
JsonArray ja = jsin.get_array();
while (ja.has_more()) {
const std::string mod = ja.next_string();
if( mod.empty() || std::find(amo.begin(), amo.end(), mod) != amo.end() ) {
continue;
}
if( obsolete_mod_list.count( mod ) ) {
obsolete_mod_found = true;
continue;
}
amo.push_back(mod);
}
} catch (std::string e) {
DebugLog( D_ERROR, DC_ALL ) << "worldfactory: loading mods list failed: " << e;
}
if( obsolete_mod_found ) {
// If we found an obsolete mod, overwrite the mod list without the obsolete one.
save_mods_list(world);
}
}
/**
* Add to the list the single called.
*/
void SimpleInlinePass::select_single_called(
Scope& scope, std::unordered_set<DexMethod*>& methods) {
std::unordered_map<DexMethod*, int> calls;
for (const auto& method : methods) {
calls[method] = 0;
}
// count call sites for each method
walk_opcodes(scope, [](DexMethod* meth) { return true; },
[&](DexMethod* meth, DexInstruction* insn) {
if (is_invoke(insn->opcode())) {
auto mop = static_cast<DexOpcodeMethod*>(insn);
auto callee = resolve_method(
mop->get_method(), opcode_to_search(insn), resolved_refs);
if (callee != nullptr && callee->is_concrete()
&& methods.count(callee) > 0) {
calls[callee]++;
}
}
});
// pick methods with a single call site and add to candidates.
// This vector usage is only because of logging we should remove it
// once the optimization is "closed"
std::vector<std::vector<DexMethod*>> calls_group(MAX_COUNT);
for (auto call_it : calls) {
if (call_it.second >= MAX_COUNT) {
calls_group[MAX_COUNT - 1].push_back(call_it.first);
continue;
}
calls_group[call_it.second].push_back(call_it.first);
}
assert(method_breakup(calls_group));
for (auto callee : calls_group[1]) {
inlinable.insert(callee);
}
}
int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int& db_flags)
{
std::vector<std::string> db_args;
boost::split(db_args, db_arg_str, boost::is_any_of("#"));
db_type = db_args.front();
boost::algorithm::trim(db_type);
if (db_args.size() == 1)
{
return 0;
}
else if (db_args.size() > 2)
{
std::cerr << "unrecognized database argument format: " << db_arg_str << ENDL;
return 1;
}
std::string db_arg_str2 = db_args[1];
boost::split(db_args, db_arg_str2, boost::is_any_of(","));
// optionally use a composite mode instead of individual flags
const std::unordered_set<std::string> db_modes {"safe", "fast", "fastest"};
std::string db_mode;
if (db_args.size() == 1)
{
if (db_modes.count(db_args[0]) > 0)
{
db_mode = db_args[0];
}
}
if (! db_mode.empty())
{
db_flags = get_db_flags_from_mode(db_mode);
}
return 0;
}
void stepFunction(
const std::unordered_set<unsigned int>& excitatory_neurons,
double ***state,
const unsigned int ind_old,
const unsigned int ind_new,
double *state_K1,
double *state_K2,
double *state_K3,
double *state_K4,
double *state_temp_1,
double *state_temp_2,
double *state_temp_3,
const double *sumFootprintAMPA,
const double *sumFootprintNMDA,
const double *sumFootprintGABAA,
const unsigned int numNeurons,
const unsigned int stateSize,
const double dt,
std::vector<double> *spikeTimes_e,
std::vector<double> *spikeNeuronIndices_e,
std::vector<double> *spikeTimes_i,
std::vector<double> *spikeNeuronIndices_i,
const unsigned int firstNeuron,
const unsigned int lastNeuron
)
{
for (unsigned int indexOfNeuron = firstNeuron; indexOfNeuron < lastNeuron;
indexOfNeuron += 1)
{
if (excitatory_neurons.count(indexOfNeuron))
{
state[ind_new][indexOfNeuron][0] =
state[ind_old][indexOfNeuron][0] + 1;
runge_kutta_generic(
(const double **)state[ind_old],
state_K1,
state_K2,
state_K3,
state_K4,
state_temp_1,
state_temp_2,
state_temp_3,
numNeurons,
stateSize,
indexOfNeuron,
1,
sumFootprintAMPA,
sumFootprintNMDA,
sumFootprintGABAA,
dt,
(*golomb::f_dV_dt),
state[ind_new][indexOfNeuron]);
runge_kutta((*golomb::f_I_Na_dh_dt), 2);
runge_kutta((*golomb::f_dn_dt), 3);
runge_kutta((*golomb::f_dz_dt), 4);
runge_kutta((*golomb::f_dsAMPA_dt), 5);
runge_kutta((*golomb::f_dxNMDA_dt), 6);
runge_kutta((*golomb::f_dsNMDA_dt), 7);
state[ind_new][indexOfNeuron][8] =
state[ind_old][indexOfNeuron][8];
state[ind_new][indexOfNeuron][9] =
state[ind_old][indexOfNeuron][9];
if (((int)state[ind_new][indexOfNeuron][1]) >= 20)
{
#ifdef USE_STD_THREADS
std::lock_guard<std::mutex> lk(m);
#endif // ifdef USE_STD_THREADS
spikeTimes_e->push_back(
(state[ind_new][indexOfNeuron][0]) * dt);
spikeNeuronIndices_e->push_back(indexOfNeuron);
}
} else {
state[ind_new][indexOfNeuron][0] =
state[ind_old][indexOfNeuron][0] + 1;
runge_kutta_generic(
(const double **)state[ind_old],
state_K1,
state_K2,
state_K3,
state_K4,
state_temp_1,
state_temp_2,
state_temp_3,
numNeurons,
stateSize,
indexOfNeuron,
1,
sumFootprintAMPA,
sumFootprintNMDA,
sumFootprintGABAA,
dt,
(*wang_buzsaki::f_dV_dt),
state[ind_new][indexOfNeuron]);
runge_kutta((*wang_buzsaki::f_I_Na_dh_dt), 2);
runge_kutta((*wang_buzsaki::f_I_Kdr_dn_dt), 3);
state[ind_new][indexOfNeuron][4] =
state[ind_old][indexOfNeuron][4];
state[ind_new][indexOfNeuron][5] =
state[ind_old][indexOfNeuron][5];
state[ind_new][indexOfNeuron][6] =
state[ind_old][indexOfNeuron][6];
state[ind_new][indexOfNeuron][7] =
state[ind_old][indexOfNeuron][7];
runge_kutta((*wang_buzsaki::f_dsGABAA_dt), 8);
state[ind_new][indexOfNeuron][9] =
state[ind_old][indexOfNeuron][9];
if (((int)state[ind_new][indexOfNeuron][1]) >= 20)
{
#ifdef USE_STD_THREADS
std::lock_guard<std::mutex> lk(m);
#endif // ifdef USE_STD_THREADS
spikeTimes_i->push_back(
(state[ind_new][indexOfNeuron][0]) * dt);
spikeNeuronIndices_i->push_back(indexOfNeuron);
}
}
}
}
static bool allow_ext_entity_protocol(const String& protocol) {
return s_ext_entity_whitelist.count(protocol.get());
}
char getOps(std::string const& s, int& pos) {
pos = s.find_first_not_of(" ", pos); // skip all spaces
if (pos == std::string::npos) { return NON_OP; }
auto res = s.at(pos++);
return validOps.count(res) ? res : NON_OP;
}
inline bool EndgameModule::drawnEndgame(HashKey materialHashKey) const
{
return mFideDrawnEndgames.count(materialHashKey) > 0 || mOtherDrawnEndgames.count(materialHashKey) > 0;
}
bool KeyboardDevice::writeText(const QString &text, int delay, bool noUnicodeCharacters) const
{
#ifdef Q_OS_UNIX
bool result = true;
KeySym keySym[2];
std::wstring wideString = text.toStdWString();
wchar_t wcSinglecharStr[2] = {L'\0'};
for(unsigned int i = 0; wideString[i] != L'\0' && i < wideString.size(); ++i)
{
wcSinglecharStr[0] = wideString[i];
//KeySym lookup
keySym[0] = ActionTools::KeySymHelper::wcharToKeySym(wcSinglecharStr[0]);
keySym[1] = 0;
if(keySym[0] == 0 || ActionTools::KeySymHelper::keySymToKeyCode(keySym[0]) == 0)
{
//No keycode found -> try to find a Multi_key combination for this character
keySym[0] = 0;
for(int j = 0; j < ActionTools::KeySymHelper::MULTIKEY_MAP_SIZE; ++j)
{
if(wcSinglecharStr[0] == ActionTools::KeySymHelper::multikeyMapChar[j])//Found
{
keySym[0] = ActionTools::KeySymHelper::wcharToKeySym(ActionTools::KeySymHelper::multikeyMapFirst[j]);
keySym[1] = ActionTools::KeySymHelper::wcharToKeySym(ActionTools::KeySymHelper::multikeyMapSecond[j]);
if((ActionTools::KeySymHelper::keySymToKeyCode(keySym[0]) == 0)
|| (ActionTools::KeySymHelper::keySymToKeyCode(keySym[1]) == 0))
keySym[0] = 0;//Character not supported
break;
}
}
}
if(keySym[0])
{
if(keySym[1])//Multi key sequence
{
result &= sendKey("Multi_key");
result &= sendCharacter(keySym[0]);
result &= sendCharacter(keySym[1]);
}
else//Single key
result &= sendCharacter(keySym[0]);
}
if(delay > 0)
ActionTools::CrossPlatform::sleep(delay);
}
return result;
#endif
#ifdef Q_OS_WIN
std::array<INPUT, 2> input;
SecureZeroMemory(input.data(), input.size() * sizeof(INPUT));
bool result = true;
for(int i = 0; i < 2; ++i)
{
input[i].type = INPUT_KEYBOARD;
input[i].ki.wVk = 0;
if(noUnicodeCharacters)
input[i].ki.dwFlags = KEYEVENTF_SCANCODE | (i == 0 ? 0 : KEYEVENTF_KEYUP);
else
input[i].ki.dwFlags = KEYEVENTF_UNICODE | (i == 0 ? 0 : KEYEVENTF_KEYUP);
input[i].ki.time = 0;
input[i].ki.dwExtraInfo = 0;
}
HKL keyboardLayout = GetKeyboardLayout(0);
auto sendModifiersFunction = [&keyboardLayout](int key, int additionalFlags)
{
INPUT modifierInput;
SecureZeroMemory(&modifierInput, sizeof(INPUT));
modifierInput.type = INPUT_KEYBOARD;
modifierInput.ki.dwFlags = KEYEVENTF_SCANCODE | additionalFlags;
modifierInput.ki.wScan = MapVirtualKeyEx(key, MAPVK_VK_TO_VSC, keyboardLayout);
if(extendedKeys.count(key) > 0)
modifierInput.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
SendInput(1, &modifierInput, sizeof(INPUT));
};
for(int i = 0; i < text.length(); ++i)
{
SHORT virtualKey = 0;
if(noUnicodeCharacters)
{
virtualKey = VkKeyScanEx(text[i].unicode(), keyboardLayout);
auto scanCode = MapVirtualKeyEx(LOBYTE(virtualKey), MAPVK_VK_TO_VSC, keyboardLayout);
if(extendedKeys.count(virtualKey) > 0)
{
input[0].ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
input[1].ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
}
if(HIBYTE(virtualKey) & 1) //Shift
sendModifiersFunction(VK_LSHIFT, 0);
if(HIBYTE(virtualKey) & 2) //Control
sendModifiersFunction(VK_LCONTROL, 0);
if(HIBYTE(virtualKey) & 4) //Alt
sendModifiersFunction(VK_LMENU, 0);
input[0].ki.wVk = input[1].ki.wVk = virtualKey;
input[0].ki.wScan = input[1].ki.wScan = scanCode;
}
else
{
input[0].ki.wScan = input[1].ki.wScan = text[i].unicode();
}
result &= (SendInput(2, input.data(), sizeof(INPUT)) != 0);
if(noUnicodeCharacters)
{
if(HIBYTE(virtualKey) & 4) //Alt
sendModifiersFunction(VK_LMENU, KEYEVENTF_KEYUP);
if(HIBYTE(virtualKey) & 2) //Control
sendModifiersFunction(VK_LCONTROL, KEYEVENTF_KEYUP);
if(HIBYTE(virtualKey) & 1) //Shift
sendModifiersFunction(VK_LSHIFT, KEYEVENTF_KEYUP);
}
if(delay > 0)
ActionTools::CrossPlatform::sleep(delay);
}
return result;
#endif
}
bool is_kept_member(DexField* sfield,
const std::unordered_set<DexField*>& keep_members) {
return keep_members.count(sfield);
}
bool isBroadcasting(Node *node) {
return broadcasting.count(node->kind());
}
void insert(const K& newk) {
if (keys_to_insert.count(newk) == 0) {
keys_to_insert.insert(newk);
}
}
bool isProtected(T* product)
{
std::lock_guard<std::mutex> lock(m_mutex);
return m_protected.count(product) == 1;
}
StrPair loadContent(const StrPair& url)
{
const int MAX_BUF_SIZE = 1024*1000;
const int READ_BUF_SIZE = 1024*16;
auto&& host = url.first;
auto&& path = url.second;
JLOG("loading url: " << host << ", " << path);
Resolver r;
Resolver::EndPoints ends = r.resolve(host, 80);
VERIFY(ends != Resolver::EndPoints(), "Cannot resolve hostname: " + host);
Socket s;
s.connect(*ends);
Str req =
"GET " + path + " HTTP/1.1" EOL
"Host: " + host + EOL EOL;
s.write(req);
Str resp;
Str buf;
size_t header = std::string::npos;
while (header == std::string::npos)
{
VERIFY(resp.size() < MAX_BUF_SIZE, "Header is too large");
buf.resize(READ_BUF_SIZE);
s.partialRead(buf);
VERIFY(!buf.empty(), "Empty buffer on partial read");
resp += buf;
header = resp.find(EOL EOL);
}
Str head = resp.substr(0, header);
header += 4; // add 2 EOLs
static const regex eStatus("^http/1\\.[01] ([\\d]{3})", regex::icase);
smatch whatStatus;
bool result = regex_search(head, whatStatus, eStatus);
VERIFY(result, "Invalid http status header");
Str status = whatStatus[1];
static const std::unordered_set<Str> allowedStatuses = {"200", "301", "302", "303"};
VERIFY(allowedStatuses.count(status), "Unexpected status: " + status);
static const regex e("content-length: *(\\d+)", regex::icase);
smatch what;
result = regex_search(head, what, e);
if (result)
{
int len = std::atoi(Str(what[1]).c_str());
VERIFY(len > 0 && len < MAX_BUF_SIZE, "Content length: invalid value");
buf.resize(len - (resp.size() - header));
s.read(buf);
resp += buf;
}
else
{
static const regex et("transfer-encoding: *chunked", regex::icase);
// read chunks
result = regex_search(head, et);
VERIFY(result, "Either content-length or transfer-encoding must be present in header");
while (resp.find(EOL EOL, resp.size() - 4) == std::string::npos)
{
VERIFY(resp.size() < MAX_BUF_SIZE, "Response is too large");
buf.resize(READ_BUF_SIZE);
s.partialRead(buf);
VERIFY(!buf.empty(), "Empty buffer on partial read");
resp += buf;
}
}
Str body = resp.substr(header);
return {host, body};
}
bool isNonheapRoot(void* p) {
if (p > max_nonheap_root || p < min_nonheap_root)
return false;
return nonheap_roots.count(p) != 0;
}
bool isPendingDelete(T* product)
{
std::lock_guard<std::mutex> lock(m_mutex);
return m_pendingDelete.count(product) == 1;
}
bool isUgly2(int n){
return n == 1 ||
(n%2 == 0 && _uglyNumber.count(n/2)) ||
(n%3 == 0 && _uglyNumber.count(n/3)) ||
(n%5 == 0 && _uglyNumber.count(n/5));
}
std::pair<uint, std::pair<goals, goals>> parse_goals(
parser& p,
std::vector<warning>& warnings_list,
const std::unordered_set<char>& declared_pieces,
const board& declared_board)throw(goals_parse_error,parse_error){
uint turns_limit;
goals uppercase_player_goals;
goals lowercase_player_goals;
if(!p.expect_string("<GOALS>"))
throw parse_error(p.get_line_number(), p.get_char_in_line_number(), "Goals segment must begin with \'<GOALS>\' string");
p.expect_whitespace();
parser_result<int> turns_limit_result = p.expect_int();
if(!turns_limit_result)
throw goals_parse_error(turns_limit_result.info.line_number, turns_limit_result.info.char_number, turns_limit_result.info.human_readable_info.c_str());
if(turns_limit_result.result < 1)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Turns limit must be positive");
turns_limit = turns_limit_result.result;
p.expect_whitespace();
if(p.expect_plain_char()!='&')
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Turns limit must be terminated with \'&\'");
p.expect_whitespace();
char next_char = p.expect_plain_char();
bool ignore;
while(next_char == '@' || next_char == '#'){
ignore = false;
if(next_char == '@'){
next_char = p.expect_plain_char();
bool uppercase_player;
if(isupper(next_char))
uppercase_player = true;
else if(islower(next_char)){
uppercase_player = false;
next_char = toupper(next_char);
}
else
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected letter after \'@\'");
if(!declared_pieces.count(next_char)){
ignore = true;
warnings_list.push_back(warning(p.get_line_number(), p.get_char_in_line_number(), "Undeclared piece (piece doesn't appear in the previous board declaration)"));
}
char piece_symbol = next_char;
do{
p.expect_whitespace();
parser_result<int> x_result = p.expect_int();
if(!x_result)
throw goals_parse_error(x_result.info.line_number, x_result.info.char_number, x_result.info.human_readable_info.c_str());
if(x_result.result < 0)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "x coordinate must be non-negative");
if(!p.expect_whitespace())
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected whitespace after x coordinate");
parser_result<int> y_result = p.expect_int();
if(!y_result)
throw goals_parse_error(y_result.info.line_number, y_result.info.char_number, y_result.info.human_readable_info.c_str());
if(y_result.result < 0)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "y coordinate must be non-negative");
if(!declared_board.inside(x_result.result, y_result.result)){
ignore = true;
warnings_list.push_back(warning(p.get_line_number(), p.get_char_in_line_number(), "Given point is outside the board"));
}
if(!ignore){
if(uppercase_player)
uppercase_player_goals.add_piece_placement_goal(piece_symbol, x_result.result, y_result.result);
else
lowercase_player_goals.add_piece_placement_goal(piece_symbol, x_result.result, y_result.result);
}
p.expect_whitespace();
next_char = p.expect_plain_char();
if(next_char != ',' && next_char != '&')
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected \',\' or \'&\'");
}while(next_char != '&');
}
else{
next_char = p.expect_plain_char();
bool uppercase_player;
if(isupper(next_char))
uppercase_player = false;
else if(islower(next_char)){
uppercase_player = true;
next_char = toupper(next_char);
}
else
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected letter after \'#\'");
if(!declared_pieces.count(next_char)){
ignore = true;
warnings_list.push_back(warning(p.get_line_number(), p.get_char_in_line_number(), "Undeclared piece (piece doesn't appear in the previous board declaration)"));
}
p.expect_whitespace();
parser_result<int> number_of_pieces_result = p.expect_int();
if(!number_of_pieces_result)
throw goals_parse_error(number_of_pieces_result.info.line_number, number_of_pieces_result.info.char_number, number_of_pieces_result.info.human_readable_info.c_str());
if(number_of_pieces_result.result < 0)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Number of piece captures must be non negative");
if(!ignore){
if(uppercase_player)
uppercase_player_goals.add_piece_capture_goal(next_char, number_of_pieces_result.result);
else
lowercase_player_goals.add_piece_capture_goal(next_char, number_of_pieces_result.result);
}
p.expect_whitespace();
if(p.expect_plain_char()!='&')
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Capture goal must be terminated with \'&\'");
}
p.expect_whitespace();
next_char = p.expect_plain_char();
}
return std::make_pair(turns_limit, std::make_pair(std::move(uppercase_player_goals), std::move(lowercase_player_goals)));
}
bool
enabled (uint256 const& feature) const
{
return set_.count(feature) > 0;
}
// Given a Python tuple of raw output tensors (raw_output), set each of
// the corresponding entries in a different Python tuple (outputs) with
// these tensors wrapped with variables. We save the gradient function (self)
// to the variable if the output is not volatile (is_volatile).
//
// There is a considerable amount of complexity to handle if the operation
// that produced these output tensors is inplace. A mapping of *input*
// tensors to variables (t2var) is used to test if this occurred, and
// the set of dirty tensors (dirty_inputs) is used to figure out what to
// do in this case. After this method is run, t2var is extended with
// mappings for output tensors as well.
static void _wrap_outputs(THPFunction *self, t2var_type &t2var,
std::unordered_set<PyObject *> &dirty_inputs,
const t2var_type &shared_pairs,
PyObject *raw_output, PyObject *outputs, bool is_volatile)
{
bool is_executable = self->cdata.is_executable;
TORCH_ASSERT(!is_volatile || !is_executable);
auto cdata = is_executable ? THPFunction_asFunction(self) : nullptr;
auto flags = VarFlags(is_executable, is_volatile);
Py_ssize_t num_outputs = PyTuple_GET_SIZE(raw_output);
if (self->cdata.is_executable) {
self->output_info.clear();
self->output_info.reserve(num_outputs);
}
// Given an output tensor, find the input Variable with which it shares storage
auto get_shared_base = [&](PyObject* tensor) -> Variable {
auto input_it = t2var.find(tensor);
if (input_it != t2var.end()) {
// If the output is an input treat that as the base
return input_it->second->cdata;
}
auto it = shared_pairs.find(tensor);
if (it != shared_pairs.end()) {
// It's explicitly marked as shared via mark_shared_storage
return it->second->cdata;
}
return Variable();
};
// Wraps an output Tensor in a Variable or returns the previous wrapper in
// the case of in-place modification.
auto wrap_output = [&](at::Tensor data, Variable prev, int output_nr, bool is_modified) -> Variable {
if (!prev.defined()) {
return make_variable(std::move(data), flags, output_nr, cdata);
}
if (is_modified) {
if (prev.is_leaf() && prev.requires_grad()) {
throw std::runtime_error("a leaf Variable that requires grad has been used in an in-place operation.");
}
// If the input was modified, transplant the grad_fn in the graph:
// grad_fn <- variable <- self ==> grad_fn <- self <- variable
prev.get()->grad.reset();
prev.get()->hooks.clear();
if (auto grad_acc_fn = prev.get()->grad_accumulator.lock()) {
auto grad_acc = dynamic_cast<AccumulateGrad*>(grad_acc_fn.get());
grad_acc->variable.reset();
}
prev.rebase_history(flags, output_nr, cdata);
return prev;
}
// An input has been returned, but it wasn't modified. Return it as a view
// so that we can attach a new grad_fn to the Variable.
return make_variable_view(std::move(prev), std::move(data), flags, output_nr, cdata);
};
t2var_type output2var;
for (int i = 0; i < num_outputs; i++) {
PyObject *output = PyTuple_GET_ITEM(raw_output, i);
THPVariable* output_var;
auto it = output2var.find(output);
if (it != output2var.end()) {
output_var = it->second;
Py_INCREF(output_var);
} else {
// Wrap the output in a Variable
bool is_modified = dirty_inputs.count(output) > 0;
Variable var = wrap_output(
torch::createTensor(output),
get_shared_base(output),
i,
is_modified);
output_var = (THPVariable*)THPVariable_Wrap(var);
if (!output_var) throw python_error();
// We already have the data tensor wrapped as a PyObject*
Py_INCREF(output);
Py_CLEAR(output_var->data);
output_var->data = output;
output2var[output] = output_var;
}
if (self->cdata.is_executable) {
self->output_info.emplace_back(output_var->cdata);
}
PyTuple_SET_ITEM(outputs, i, (PyObject*)output_var);
}
// Add every entry in output2var to t2var
for (auto& entry : output2var) {
t2var[entry.first] = entry.second;
}
}
bool S4Prover::isSatisfiable(SddNode* alpha, SddManager* m, std::unordered_set<SddLiteral> permVars, SddNode* permSdd,
std::unordered_set<SddNode*,SddHasher>& assumedSatSdds , std::unordered_set<SddLiteral>& responsibleVars) {
//Match against cache
if (satCache.count(alpha) == 1) {
return true;
}
//Base cases
if (sdd_node_is_true(alpha)) {
return true;
}
if (sdd_node_is_false(alpha)) {
return false;
}
//Scrape off a single satisfying set, corresponding to a single open tableaux branch.
std::vector<SddLiteral> branch = getOpenBranch(alpha, std::vector<SddLiteral>());
SddNode* branchSdd = branchToSDD(branch,m);
sdd_ref(branchSdd,m);
/*std::cout << "BRANCH\n\n";
for (SddLiteral i : branch) {
if (i < 0) std::cout << "~" << *literalsToAtoms[-i] << "\n\n";
else std::cout << *literalsToAtoms[i] << "\n\n";
}
std::cout << "BRANCH END\n\n";*/
//Extract all modal atoms from the branch.
std::vector<SddLiteral> boxes;
std::vector<SddLiteral> negBoxes;
if (extractModals(branch,boxes,negBoxes) == 0) {
return true;
};
//Checks for new boxed variables
SddNode* tmp;
std::unordered_set<SddLiteral> newPermVars = permVars;
std::vector<SddLiteral> unboxed;
SddNode* postUnboxingBranch = sdd_conjoin(sdd_manager_true(m),branchSdd,m);
sdd_ref(postUnboxingBranch,m);
SddNode* newPermSdd = sdd_conjoin(sdd_manager_true(m),permSdd,m);
sdd_ref(newPermSdd,m);
for (SddLiteral i : boxes) {
if (newPermVars.count(i) == 0) {
unboxed.push_back(i);
newPermVars.insert(i);
postUnboxingBranch = sdd_conjoin(tmp = postUnboxingBranch, compiler::KtoSDD(&literalsToAtoms[i]->getleft(),m),m);
sdd_deref(tmp,m); sdd_ref(postUnboxingBranch,m);
newPermSdd = sdd_conjoin(tmp = newPermSdd, compiler::KtoSDD(&literalsToAtoms[i]->getleft(),m),m);
sdd_deref(tmp,m); sdd_ref(newPermSdd,m);
newPermSdd = sdd_conjoin(tmp = newPermSdd, compiler::KtoSDD(literalsToAtoms[i],m),m);
sdd_deref(tmp,m); sdd_ref(newPermSdd,m);
//If becomes false while unboxing, recurse.
if (sdd_node_is_false(postUnboxingBranch)) {
//Determine minimal set of unboxed variables
std::vector<SddLiteral> minLits;
minLits.push_back(i);
responsibleVars.insert(i);
std::vector<SddLiteral>::iterator endIt = --(unboxed.end());
SddNode* minimalSdd = sdd_conjoin(compiler::KtoSDD(&literalsToAtoms[i]->getleft(),m),branchSdd,m);
sdd_ref(minimalSdd,m);
SddNode* minBoxVarsSdd = sdd_conjoin(compiler::KtoSDD(&literalsToAtoms[i]->getleft(),m),sdd_manager_true(m),m);
sdd_ref(minBoxVarsSdd,m);
while (true) {
sdd_deref(postUnboxingBranch,m);
postUnboxingBranch = sdd_conjoin(minimalSdd, sdd_manager_true(m), m);
sdd_ref(postUnboxingBranch,m);
if (sdd_node_is_false(postUnboxingBranch)) break; //Last one added made it false
for (std::vector<SddLiteral>::iterator v = unboxed.begin();
v != endIt; ++v) {
postUnboxingBranch = sdd_conjoin(tmp = postUnboxingBranch, compiler::KtoSDD(&literalsToAtoms[*v]->getleft(),m),m);
sdd_deref(tmp,m); sdd_ref(postUnboxingBranch,m);
if (sdd_node_is_false(postUnboxingBranch)) {
//Last one added made it false
minimalSdd = sdd_conjoin(tmp = minimalSdd, compiler::KtoSDD(&literalsToAtoms[*v]->getleft(),m),m);
sdd_deref(tmp,m); sdd_ref(minimalSdd,m);
minBoxVarsSdd = sdd_conjoin(tmp = minBoxVarsSdd,compiler::KtoSDD(&literalsToAtoms[*v]->getleft(),m),m);
sdd_deref(tmp,m); sdd_ref(minBoxVarsSdd,m);
minLits.push_back(*v);
responsibleVars.insert(*v);
endIt = v;
break;
}
}
}
// Determine minimal set of branch variables together with unboxed variables
std::vector<SddLiteral>::iterator BendIt = branch.end();
sdd_deref(minimalSdd,m);
minimalSdd = sdd_conjoin(sdd_manager_true(m),minBoxVarsSdd,m);
sdd_ref(minimalSdd,m);
while (true) {
sdd_deref(minBoxVarsSdd,m);
minBoxVarsSdd = sdd_conjoin(minimalSdd, sdd_manager_true(m), m);
sdd_ref(minBoxVarsSdd,m);
if (sdd_node_is_false(minBoxVarsSdd)) break; //Last one added made it false
for (std::vector<SddLiteral>::iterator v = branch.begin();
v != BendIt; ++v) {
minBoxVarsSdd = sdd_conjoin(tmp = minBoxVarsSdd, sdd_manager_literal(*v,m), m);
sdd_deref(tmp,m); sdd_ref(minBoxVarsSdd,m);
if (sdd_node_is_false(minBoxVarsSdd)) {
//Last one added made it false
minimalSdd = sdd_conjoin(tmp = minimalSdd, sdd_manager_literal(*v,m),m);
sdd_deref(tmp,m); sdd_ref(minimalSdd,m);
minLits.push_back(*v);
responsibleVars.insert(*v);
BendIt = v;
break;
}
}
}
sdd_deref(minimalSdd,m); sdd_deref(postUnboxingBranch,m); sdd_deref(minBoxVarsSdd,m);
//std::cout << *literalsToAtoms[minLits[0]] << " and " << *literalsToAtoms[minLits[1]] << "\n";
SddNode* beta = refineSdd(minLits, alpha, m);
sdd_ref(beta,m);
dependentSdds.insert(alpha);
bool isSat = isSatisfiableRefined(beta, m, permVars, permSdd, assumedSatSdds, responsibleVars);
dependentSdds.erase(alpha);
sdd_deref(beta,m); sdd_deref(branchSdd,m); sdd_deref(newPermSdd,m);
return isSat;
}
}
}
// There were new boxes, so recurse.
if (!unboxed.empty()) {
dependentSdds.insert(alpha);
std::unordered_set<SddLiteral> postResponsibleVars;
if (!isSatisfiable(postUnboxingBranch,m,newPermVars,newPermSdd,assumedSatSdds, postResponsibleVars)) {
std::vector<SddLiteral> minLits;
for (SddLiteral v : branch) {
if (postResponsibleVars.count(v) == 1) {
minLits.push_back(v);
responsibleVars.insert(v);
}
}
for (SddLiteral v : unboxed) {
std::unordered_set<SddLiteral> children;
KFormula::computeChildrenBoxS4(&literalsToAtoms[v]->getleft(), children);
if (shareAnElement(postResponsibleVars, children)) {
minLits.push_back(v);
responsibleVars.insert(v);
}
}
SddNode* beta = refineSdd(minLits, alpha, m);
sdd_ref(beta,m);
bool isSat = isSatisfiableRefined(beta, m, permVars, permSdd, assumedSatSdds, responsibleVars);
sdd_deref(beta,m); sdd_deref(branchSdd,m); sdd_deref(newPermSdd,m); sdd_deref(postUnboxingBranch,m);
dependentSdds.erase(alpha);
return isSat;
}
sdd_deref(branchSdd,m); sdd_deref(newPermSdd,m);
dependentSdds.erase(alpha);
return true;
}
// There are no new boxes, so start undiamonding.
sdd_deref(branchSdd,m);
if (negBoxes.empty()) {
return true;
}
dependentSdds.insert(alpha);
SddNode* nextWorld;
for (SddLiteral i : negBoxes) {
nextWorld = sdd_conjoin(permSdd, sdd_negate(compiler::KtoSDD(&literalsToAtoms[-i]->getleft(),m),m),m);
sdd_ref(nextWorld,m);
if (sdd_node_is_false(nextWorld)) {
sdd_deref(nextWorld,m);
nextWorld = sdd_conjoin(sdd_manager_true(m), sdd_negate(compiler::KtoSDD(&literalsToAtoms[-i]->getleft(),m),m),m);
sdd_ref(nextWorld,m);
responsibleVars.insert(i);
std::vector<SddLiteral> minLits;
minLits.push_back(i);
// Determine a minimal unsatisfiable subset.
std::unordered_set<SddLiteral>::iterator endIt = permVars.end();
SddNode* minimalSdd = sdd_conjoin(nextWorld, sdd_manager_true(m),m);
sdd_ref(minimalSdd,m);
while (true) {
sdd_deref(nextWorld,m);
nextWorld = sdd_conjoin(minimalSdd, sdd_manager_true(m), m);
sdd_ref(nextWorld,m);
if (sdd_node_is_false(nextWorld)) break;
for (std::unordered_set<SddLiteral>::iterator v = permVars.begin();
v != endIt; ++v) {
nextWorld = sdd_conjoin(tmp = nextWorld,compiler::KtoSDD(&literalsToAtoms[*v]->getleft(),m) ,m);
sdd_deref(tmp, m); sdd_ref(nextWorld,m);
nextWorld = sdd_conjoin(tmp = nextWorld,sdd_manager_literal(*v,m) ,m);
sdd_deref(tmp, m); sdd_ref(nextWorld,m);
if (sdd_node_is_false(nextWorld)) {
minimalSdd = sdd_conjoin(tmp = minimalSdd,compiler::KtoSDD(&literalsToAtoms[*v]->getleft(),m) ,m);
sdd_deref(tmp, m); sdd_ref(minimalSdd,m);
minimalSdd = sdd_conjoin(tmp = minimalSdd,sdd_manager_literal(*v,m) ,m);
sdd_deref(tmp, m); sdd_ref(minimalSdd,m);
minLits.push_back(*v);
responsibleVars.insert(*v);
endIt = v;
break;
}
}
}
SddNode* beta = refineSdd(minLits, alpha, m);
sdd_ref(beta,m);
bool isSat = isSatisfiableRefined(beta, m, permVars, permSdd, assumedSatSdds, responsibleVars);
sdd_deref(beta,m); sdd_deref(nextWorld,m); sdd_deref(minimalSdd,m);
dependentSdds.erase(alpha);
return isSat;
}
if (dependentSdds.count(nextWorld) == 1) {
//Loop detected
assumedSatSdds.insert(nextWorld);
continue;
}
std::unordered_set<SddNode*,SddHasher> postModalAssumedSatSdds = assumedSatSdds;
std::unordered_set<SddLiteral> postResponsibleVars;
if (!isSatisfiable(nextWorld,m,permVars,permSdd,postModalAssumedSatSdds, postResponsibleVars)) {
std::vector<SddLiteral> minLits;
bool newPostModalJumpResVarsAdded = true;
while (newPostModalJumpResVarsAdded) {
newPostModalJumpResVarsAdded = false;
for (std::unordered_set<SddLiteral>::iterator v = permVars.begin();
v != permVars.end(); ++v) {
if (responsibleVars.count(*v) != 0) {
continue;
}
std::unordered_set<SddLiteral> children = getChildren(*v);
children.insert(*v);
if (shareAnElement(postResponsibleVars, children)) {
minLits.push_back(*v);
responsibleVars.insert(*v);
// Add in other children to postModalJumpResVars
postResponsibleVars.insert(children.begin(),
children.end());
newPostModalJumpResVarsAdded = true;
}
}
if (responsibleVars.count(i) != 0) {
// Don't bother, we've already accounted for this dia var.
} else if (shareAnElement(postResponsibleVars, getChildren(i))) {
// Note, <>phi stored as []~phi, thus the nith.
minLits.push_back(i);
responsibleVars.insert(i);
// Add in other children to postModalJumpResVars
postResponsibleVars.insert(getChildren(i).begin(),
getChildren(i).end());
newPostModalJumpResVarsAdded = true;
}
}
SddNode* beta = refineSdd(minLits, alpha, m);
sdd_ref(beta,m);
bool isSat = isSatisfiableRefined(beta, m, permVars, permSdd, assumedSatSdds, responsibleVars);
sdd_deref(beta,m); sdd_deref(nextWorld,m);
dependentSdds.erase(alpha);
return isSat;
}
assumedSatSdds.insert(postModalAssumedSatSdds.begin(),postModalAssumedSatSdds.end());
}
satCache.insert(alpha);
dependentSdds.erase(alpha);
return true;
}