void VoxelTreeNode::calculateSphereRadius(const Transform& transform) { if(isAtomic()) { m_sphere.setRadius(0.5f * transform.scale()); } else { m_sphere.setRadius((glm::length(glm::vec3(m_gridAABB.urb() - m_gridAABB.llf() + glm::ivec3(1, 1, 1))/2.0f)) * transform.scale()) ; } m_cachedSphereTransform.setScale(transform.scale()); }
void VoxelTreeNode::remove(Voxel* voxel) { if (isAtomic()) { assert(m_voxel != nullptr); m_voxel->setVoxelTreeNode(nullptr); m_voxel = nullptr; setActive(false); } else { cellSubnode(voxel->cell())->remove(voxel); } }
Arabica::XPath::NodeSet<std::string> InterpreterDraft6::selectTransitions(const std::string& event) { Arabica::XPath::NodeSet<std::string> enabledTransitions; NodeSet<std::string> states; for (unsigned int i = 0; i < _configuration.size(); i++) { if (isAtomic(_configuration[i])) states.push_back(_configuration[i]); } states.to_document_order(); #if 0 std::cout << "Atomic states: " << std::endl; for (int i = 0; i < states.size(); i++) { std::cout << states[i] << std::endl << "----" << std::endl; } std::cout << std::endl; #endif unsigned int index = 0; while(states.size() > index) { bool foundTransition = false; NodeSet<std::string> transitions = filterChildElements(_nsInfo.xmlNSPrefix + "transition", states[index]); for (unsigned int k = 0; k < transitions.size(); k++) { if (isEnabledTransition(transitions[k], event)) { enabledTransitions.push_back(transitions[k]); foundTransition = true; goto LOOP; } } if (!foundTransition) { Node<std::string> parent = states[index].getParentNode(); if (parent) { states.push_back(parent); } } LOOP: index++; } enabledTransitions = filterPreempted(enabledTransitions); #if 0 std::cout << "Enabled transitions: " << std::endl; for (int i = 0; i < enabledTransitions.size(); i++) { std::cout << DOMUtils::xPathForNode(enabledTransitions[i]) << std::endl; } std::cout << std::endl; #endif return enabledTransitions; }
Arabica::XPath::NodeSet<std::string> InterpreterDraft6::selectEventlessTransitions() { Arabica::XPath::NodeSet<std::string> enabledTransitions; NodeSet<std::string> states; for (unsigned int i = 0; i < _configuration.size(); i++) { if (isAtomic(_configuration[i])) states.push_back(_configuration[i]); } states.to_document_order(); #if 0 std::cout << "Atomic States: "; for (int i = 0; i < atomicStates.size(); i++) { std::cout << ATTR(atomicStates[i], "id") << ", "; } std::cout << std::endl; #endif unsigned int index = 0; while(states.size() > index) { bool foundTransition = false; NodeSet<std::string> transitions = filterChildElements(_nsInfo.xmlNSPrefix + "transition", states[index]); for (unsigned int k = 0; k < transitions.size(); k++) { if (!HAS_ATTR(transitions[k], "event") && hasConditionMatch(transitions[k])) { enabledTransitions.push_back(transitions[k]); foundTransition = true; goto LOOP; } } if (!foundTransition) { Node<std::string> parent = states[index].getParentNode(); if (parent) { states.push_back(parent); } } LOOP: index++; } #if 0 std::cout << "Enabled eventless transitions: " << std::endl; for (int i = 0; i < enabledTransitions.size(); i++) { std::cout << enabledTransitions[i] << std::endl << "----" << std::endl; } std::cout << std::endl; #endif enabledTransitions = filterPreempted(enabledTransitions); return enabledTransitions; }
void VoxelTreeNode::insert(Voxel* voxel) { assert(m_gridAABB.contains(voxel->cell())); if (isAtomic()) { assert(m_voxel == nullptr); m_voxel = voxel; m_voxel->setVoxelTreeNode(this); setActive(true); } else { if (isLeaf()) { toGroup(); } cellSubnode(voxel->cell())->insert(voxel); } }
void DebugSession::breakExecution(Data replyData) { std::lock_guard<std::recursive_mutex> lock(_mutex); std::list<XERCESC_NS::DOMElement*> configuration = _interpreter.getConfiguration(); for (auto state : configuration) { if (HAS_ATTR(state, "id")) { replyData.compound["activeStates"].array.push_back(Data(ATTR(state, "id"), Data::VERBATIM)); if (isAtomic(state)) { replyData.compound["basicStates"].array.push_back(Data(ATTR(state, "id"), Data::VERBATIM)); } } } replyData.compound["replyType"] = Data("breakpoint", Data::VERBATIM); _debugger->pushData(shared_from_this(), replyData); // wait for resume from the client _resumeCond.wait(_mutex); }
static SEXP simplify(SEXP fun, SEXP arg1, SEXP arg2) { SEXP ans; if (fun == PlusSymbol) { if (isZero(arg1)) ans = arg2; else if (isZero(arg2)) ans = arg1; else if (isUminus(arg1)) ans = simplify(MinusSymbol, arg2, CADR(arg1)); else if (isUminus(arg2)) ans = simplify(MinusSymbol, arg1, CADR(arg2)); else ans = lang3(PlusSymbol, arg1, arg2); } else if (fun == MinusSymbol) { if (arg2 == R_MissingArg) { if (isZero(arg1)) ans = Constant(0.); else if (isUminus(arg1)) ans = CADR(arg1); else ans = lang2(MinusSymbol, arg1); } else { if (isZero(arg2)) ans = arg1; else if (isZero(arg1)) ans = simplify(MinusSymbol, arg2, R_MissingArg); else if (isUminus(arg1)) { ans = simplify(MinusSymbol, PP(simplify(PlusSymbol, CADR(arg1), arg2)), R_MissingArg); UNPROTECT(1); } else if (isUminus(arg2)) ans = simplify(PlusSymbol, arg1, CADR(arg2)); else ans = lang3(MinusSymbol, arg1, arg2); } } else if (fun == TimesSymbol) { if (isZero(arg1) || isZero(arg2)) ans = Constant(0.); else if (isOne(arg1)) ans = arg2; else if (isOne(arg2)) ans = arg1; else if (isUminus(arg1)) { ans = simplify(MinusSymbol, PP(simplify(TimesSymbol, CADR(arg1), arg2)), R_MissingArg); UNPROTECT(1); } else if (isUminus(arg2)) { ans = simplify(MinusSymbol, PP(simplify(TimesSymbol, arg1, CADR(arg2))), R_MissingArg); UNPROTECT(1); } else ans = lang3(TimesSymbol, arg1, arg2); } else if (fun == DivideSymbol) { if (isZero(arg1)) ans = Constant(0.); else if (isZero(arg2)) ans = Constant(NA_REAL); else if (isOne(arg2)) ans = arg1; else if (isUminus(arg1)) { ans = simplify(MinusSymbol, PP(simplify(DivideSymbol, CADR(arg1), arg2)), R_MissingArg); UNPROTECT(1); } else if (isUminus(arg2)) { ans = simplify(MinusSymbol, PP(simplify(DivideSymbol, arg1, CADR(arg2))), R_MissingArg); UNPROTECT(1); } else ans = lang3(DivideSymbol, arg1, arg2); } else if (fun == PowerSymbol) { if (isZero(arg2)) ans = Constant(1.); else if (isZero(arg1)) ans = Constant(0.); else if (isOne(arg1)) ans = Constant(1.); else if (isOne(arg2)) ans = arg1; else ans = lang3(PowerSymbol, arg1, arg2); } else if (fun == ExpSymbol) { /* FIXME: simplify exp(lgamma( E )) = gamma( E ) */ ans = lang2(ExpSymbol, arg1); } else if (fun == LogSymbol) { /* FIXME: simplify log(gamma( E )) = lgamma( E ) */ ans = lang2(LogSymbol, arg1); } else if (fun == CosSymbol) ans = lang2(CosSymbol, arg1); else if (fun == SinSymbol) ans = lang2(SinSymbol, arg1); else if (fun == TanSymbol) ans = lang2(TanSymbol, arg1); else if (fun == CoshSymbol) ans = lang2(CoshSymbol, arg1); else if (fun == SinhSymbol) ans = lang2(SinhSymbol, arg1); else if (fun == TanhSymbol) ans = lang2(TanhSymbol, arg1); else if (fun == SqrtSymbol) ans = lang2(SqrtSymbol, arg1); else if (fun == PnormSymbol)ans = lang2(PnormSymbol, arg1); else if (fun == DnormSymbol)ans = lang2(DnormSymbol, arg1); else if (fun == AsinSymbol) ans = lang2(AsinSymbol, arg1); else if (fun == AcosSymbol) ans = lang2(AcosSymbol, arg1); else if (fun == AtanSymbol) ans = lang2(AtanSymbol, arg1); else if (fun == GammaSymbol)ans = lang2(GammaSymbol, arg1); else if (fun == LGammaSymbol)ans = lang2(LGammaSymbol, arg1); else if (fun == DiGammaSymbol) ans = lang2(DiGammaSymbol, arg1); else if (fun == TriGammaSymbol) ans = lang2(TriGammaSymbol, arg1); else if (fun == PsiSymbol){ if (arg2 == R_MissingArg) ans = lang2(PsiSymbol, arg1); else ans = lang3(PsiSymbol, arg1, arg2); } else ans = Constant(NA_REAL); /* FIXME */ #ifdef NOTYET if (length(ans) == 2 && isAtomic(CADR(ans)) && CAR(ans) != MinusSymbol) c = eval(c, rho); if (length(c) == 3 && isAtomic(CADR(ans)) && isAtomic(CADDR(ans))) c = eval(c, rho); #endif return ans; }/* simplify() */
void InterpreterDraft6::exitStates(const Arabica::XPath::NodeSet<std::string>& enabledTransitions) { NodeSet<std::string> statesToExit; monIter_t monIter; #if VERBOSE std::cout << _name << ": Enabled exit transitions: " << std::endl; for (int i = 0; i < enabledTransitions.size(); i++) { std::cout << enabledTransitions[i] << std::endl; } std::cout << std::endl; #endif for (int i = 0; i < enabledTransitions.size(); i++) { Element<std::string> t = ((Element<std::string>)enabledTransitions[i]); if (!isTargetless(t)) { Node<std::string> ancestor; Node<std::string> source = getSourceState(t); // std::cout << t << std::endl << TAGNAME(t) << std::endl; NodeSet<std::string> tStates = getTargetStates(t); bool isInternal = (HAS_ATTR(t, "type") && iequals(ATTR(t, "type"), "internal")); // external is default bool allDescendants = true; for (int j = 0; j < tStates.size(); j++) { if (!isDescendant(tStates[j], source)) { allDescendants = false; break; } } if (isInternal && allDescendants && isCompound(source)) { ancestor = source; } else { NodeSet<std::string> tmpStates; tmpStates.push_back(source); tmpStates.insert(tmpStates.end(), tStates.begin(), tStates.end()); #if VERBOSE std::cout << _name << ": tmpStates: "; for (int i = 0; i < tmpStates.size(); i++) { std::cout << ATTR(tmpStates[i], "id") << ", "; } std::cout << std::endl; #endif ancestor = findLCCA(tmpStates); } #if VERBOSE std::cout << _name << ": Ancestor: " << ATTR(ancestor, "id") << std::endl;; #endif for (int j = 0; j < _configuration.size(); j++) { if (isDescendant(_configuration[j], ancestor)) statesToExit.push_back(_configuration[j]); } } } // remove statesToExit from _statesToInvoke std::list<Node<std::string> > tmp; for (int i = 0; i < _statesToInvoke.size(); i++) { if (!isMember(_statesToInvoke[i], statesToExit)) { tmp.push_back(_statesToInvoke[i]); } } _statesToInvoke = NodeSet<std::string>(); _statesToInvoke.insert(_statesToInvoke.end(), tmp.begin(), tmp.end()); statesToExit.forward(false); statesToExit.sort(); #if VERBOSE std::cout << _name << ": States to exit: "; for (int i = 0; i < statesToExit.size(); i++) { std::cout << LOCALNAME(statesToExit[i]) << ":" << ATTR(statesToExit[i], "id") << ", "; } std::cout << std::endl; #endif for (int i = 0; i < statesToExit.size(); i++) { NodeSet<std::string> histories = filterChildElements(_nsInfo.xmlNSPrefix + "history", statesToExit[i]); for (int j = 0; j < histories.size(); j++) { Element<std::string> historyElem = (Element<std::string>)histories[j]; std::string historyType = (historyElem.hasAttribute("type") ? historyElem.getAttribute("type") : "shallow"); NodeSet<std::string> historyNodes; for (int k = 0; k < _configuration.size(); k++) { if (iequals(historyType, "deep")) { if (isAtomic(_configuration[k]) && isDescendant(_configuration[k], statesToExit[i])) historyNodes.push_back(_configuration[k]); } else { if (_configuration[k].getParentNode() == statesToExit[i]) historyNodes.push_back(_configuration[k]); } } _historyValue[historyElem.getAttribute("id")] = historyNodes; #if VERBOSE std::cout << _name << ": History node " << ATTR(historyElem, "id") << " contains: "; for (int i = 0; i < historyNodes.size(); i++) { std::cout << ATTR(historyNodes[i], "id") << ", "; } std::cout << std::endl; #endif } } for (int i = 0; i < statesToExit.size(); i++) { // --- MONITOR: beforeExitingState ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->beforeExitingState(shared_from_this(), Element<std::string>(statesToExit[i]), (i + 1 < statesToExit.size())); } USCXML_MONITOR_CATCH_BLOCK(beforeExitingState) } NodeSet<std::string> onExits = filterChildElements(_nsInfo.xmlNSPrefix + "onExit", statesToExit[i]); for (int j = 0; j < onExits.size(); j++) { Element<std::string> onExitElem = (Element<std::string>)onExits[j]; executeContent(onExitElem); } // --- MONITOR: afterExitingState ------------------------------ for(monIter_t monIter = _monitors.begin(); monIter != _monitors.end(); monIter++) { try { (*monIter)->afterExitingState(shared_from_this(), Element<std::string>(statesToExit[i]), (i + 1 < statesToExit.size())); } USCXML_MONITOR_CATCH_BLOCK(afterExitingState) } NodeSet<std::string> invokes = filterChildElements(_nsInfo.xmlNSPrefix + "invoke", statesToExit[i]); for (int j = 0; j < invokes.size(); j++) { Element<std::string> invokeElem = (Element<std::string>)invokes[j]; if (HAS_ATTR(invokeElem, "persist") && DOMUtils::attributeIsTrue(ATTR(invokeElem, "persist"))) { // extension for flattened SCXML documents, we will need an explicit uninvoke element } else { cancelInvoke(invokeElem); } } // remove statesToExit[i] from _configuration - test409 tmp.clear(); for (int j = 0; j < _configuration.size(); j++) { if (_configuration[j] != statesToExit[i]) { tmp.push_back(_configuration[j]); } } _configuration = NodeSet<std::string>(); _configuration.insert(_configuration.end(), tmp.begin(), tmp.end()); } }
void saveFunctionBody(struct dtdElement *el, FILE *f) /* Write out save function body. */ { struct dtdElChild *ec; struct dtdAttribute *att; boolean optKids = optionalChildren(el); boolean isAtom = isAtomic(el); fprintf(f, "{\n"); /* Declare variables to walk through list if need be. */ for (ec = el->children; ec != NULL; ec = ec->next) { if (ec->copyCode == '*' || ec->copyCode == '+') { char *name = ec->el->mixedCaseName; fprintf(f, "struct %s *%s;\n", name, name); } } if (optKids) fprintf(f, "boolean isNode = TRUE;\n"); fprintf(f, "if (obj == NULL) return;\n"); fprintf(f, "xapIndent(indent, f);\n"); if (el->attributes == NULL) { if (isAtom) fprintf(f, "fprintf(f, \" ->\\n\");\n"); else fprintf(f, "fprintf(f, \"<%s>\");\n", el->name); } else { fprintf(f, "fprintf(f, \"<%s\");\n", el->name); for (att = el->attributes; att != NULL; att = att->next) { if (att->required ) fprintf(f, "fprintf(f, \" %s=\\\"%%%c\\\"\", obj->%s);\n", att->name, fAttType(att->type), att->name); else { if (sameString(att->type, "INT") || sameString(att->type, "FLOAT")) { if (positiveOnly) { fprintf(f, "if (obj->%s >= 0)\n ", att->name); } fprintf(f, "fprintf(f, \" %s=\\\"%%%c\\\"\", obj->%s);\n", att->name, fAttType(att->type), att->name); } else { fprintf(f, "if (obj->%s != NULL)\n", att->name); fprintf(f, " fprintf(f, \" %s=\\\"%%%c\\\"\", obj->%s);\n", att->name, fAttType(att->type), att->name); } } } if (isAtom) fprintf(f, "fprintf(f, \"/>\\n\");\n"); else fprintf(f, "fprintf(f, \">\");\n"); } if (el->textType != NULL) { if (sameString(el->textType, "#INT")) fprintf(f, "fprintf(f, \"%%d\", obj->%s);\n", textField); else if (sameString(el->textType, "#FLOAT")) fprintf(f, "fprintf(f, \"%%f\", obj->%s);\n", textField); else fprintf(f, "fprintf(f, \"%%s\", obj->%s);\n", textField); } if (isAtom) { } else if (el->children == NULL) { fprintf(f, "fprintf(f, \"</%s>\\n\");\n", el->name); } else { if (!optKids) fprintf(f, "fprintf(f, \"\\n\");\n"); for (ec = el->children; ec != NULL; ec = ec->next) { char *name = ec->el->mixedCaseName; if (ec->copyCode == '*' || ec->copyCode == '+') { fprintf(f, "for (%s = obj->%s; %s != NULL; %s = %s->next)\n", name, name, name, name, name); fprintf(f, " {\n"); if (optKids) { fprintf(f, " if (isNode)\n"); fprintf(f, " {\n"); fprintf(f, " fprintf(f, \"\\n\");\n"); fprintf(f, " isNode = FALSE;\n"); fprintf(f, " }\n"); } fprintf(f, " %sSave(%s, indent+2, f);\n", name, name); fprintf(f, " }\n"); } else { if (optKids) { fprintf(f, "if (obj->%s != NULL)\n", name); fprintf(f, " {\n"); fprintf(f, " if (isNode)\n"); fprintf(f, " {\n"); fprintf(f, " fprintf(f, \"\\n\");\n"); fprintf(f, " isNode = FALSE;\n"); fprintf(f, " }\n"); fprintf(f, " %sSave(obj->%s, indent+2, f);\n", name, name); fprintf(f, " }\n"); } else fprintf(f, "%sSave(obj->%s, indent+2, f);\n", name, name); } } if (optKids) { fprintf(f, "if (!isNode)\n"); fprintf(f, " xapIndent(indent, f);\n"); } else { fprintf(f, "xapIndent(indent, f);\n"); } fprintf(f, "fprintf(f, \"</%s>\\n\");\n", el->name); } fprintf(f, "}\n"); fprintf(f, "\n"); }