forceinline void OmegaTree<TaskView>::insert(int i) { leaf(i).e = tasks[i].e(); leaf(i).env = static_cast<long long int>(c)*tasks[i].est()+tasks[i].e(); update(i); }
[[nodiscard]] std::set<pt> connections() const { std::set<ptpair> S; std::set<pt> P; for (size_t i = 0; i < size.x; ++i) { for (size_t j = 0; j < size.y; ++j) { for (int xx = 1; xx < 100; ++xx) { double x = .01 * xx; std::pair<pt, pt> pp = leaf(pt(i, j, x, 0), nullptr); if ((pp.first != pt()) && (pp.second != pt())) { if (S.count(pp) == 0) { S.insert(pp); P.insert(pt(i, j, x, 0)); } } pp = leaf(pt(i, j, 0, x), nullptr); if ((pp.first != pt()) && (pp.second != pt())) { if (S.count(pp) == 0) { S.insert(pp); P.insert(pt(i, j, 0, x)); } } } } } return P; }
void leaf(turtle_t &turt, double length) { double factor,i; factor=length/10; if(factor<=0.005) return; else{ for(i=2.0;i<=4.2;i=i+0.2){ turt.forward(factor); turt.turn_right(45); leaf(turt,4.2*factor/i); turt.forward(4.8*factor/i); turt.backward_move(4.8*factor/i); turt.turn_left(45); turt.forward(factor/6); turt.turn_left(45); leaf(turt,4.2*factor/i); turt.forward(4.8*factor/i); turt.backward_move(4.8*factor/i); turt.turn_right(45.15); } turt.forward(factor/8); turt.backward_move(length+3*factor); } }
OmegaTree<TaskView>::OmegaTree(Region& r, int c0, const TaskViewArray<TaskView>& t) : TaskTree<TaskView,OmegaNode>(r,t), c(c0) { for (int i=tasks.size(); i--; ) { leaf(i).e = 0; leaf(i).env = -Limits::llinfinity; } init(); }
template<class TaskView> void ExtOmegaTree<TaskView>::init(int ci0) { ci = ci0; for (int i=tasks.size(); i--; ) { leaf(i).e = 0; leaf(i).env = leaf(i).cenv = -Limits::llinfinity; } init(); }
int leaf(Tnode *r) { if(r==NULL) return 0; else if(r->lchild==NULL&&r->rchild==NULL) return 1; else return leaf(r->lchild)+leaf(r->rchild); }
void assignBMEWeights(meTree *T, double **A) { meEdge *e; e = depthFirstTraverse(T,NULL); while (NULL != e) { if ((leaf(e->head)) || (leaf(e->tail))) BalWFext(e,A); else BalWFint(e,A); e = depthFirstTraverse(T,e); } }
int leaf(BinTree T) { int n1,n2; if(!T) return 0; else if((!T->lchild) && (!T->rchild))return 1; else { n1=leaf(T->lchild); n2=leaf(T->rchild); return(n1+n2); } }
int leaf(node *r) { if(!r) return 0; else { if( NULL == r->lChild && NULL == r->rChild ) return 1; else return leaf(r->rChild) + leaf(r->lChild); } }
bool leaf(struct node *root,int le,int *lef) { if(root==NULL)return true; if(root->left==NULL &&root->right==NULL) { if(*lef==0) { *lef=le; return true; } return(*lef==le); } return leaf(root->left,le+1,lef)&& leaf(root->right,le+1,lef); }
forceinline void OmegaLambdaTree<TaskView>::shift(int i) { // i is in omega assert(leaf(i).env > -Limits::llinfinity); leaf(i).le = leaf(i).e; leaf(i).e = 0; leaf(i).lenv = leaf(i).env; leaf(i).env = -Limits::llinfinity; leaf(i).resLe = i; leaf(i).resLenv = i; update(i); }
/* * traverse the whole tree in a deletion-safe way, calling node_before at * nodes, leaf at leaves, and node_after when back at nodes, passing data along * the way through nodes. data returned by leaf() is ignored. * * Hooks can modify the pointer they're given to remove or replace themselves. */ static void traverse(topo_topology_t topology, topo_obj_t *father, void (*node_before)(topo_topology_t topology, topo_obj_t *obj, void *), void (*leaf)(topo_topology_t topology, topo_obj_t *obj, void *), void (*node_after)(topo_topology_t topology, topo_obj_t *obj, void *), void *data) { topo_obj_t *pobj, obj; if (!(*father)->first_child) { if (leaf) leaf(topology, father, data); return; } if (node_before) node_before(topology, father, data); if (!(*father)) return; for (pobj = &(*father)->first_child, obj = *pobj; obj; /* Check whether the current obj was dropped. */ (*pobj == obj ? pobj = &(*pobj)->next_sibling : 0), /* Get pointer to next object. */ obj = *pobj) traverse(topology, pobj, node_before, leaf, node_after, data); if (node_after) node_after(topology, father, data); }
/*assumes tree is only trifurcated at root*/ tree *detrifurcate(tree *T) { node *v, *w; edge *e, *f; v = T->root; if(leaf(v)) return(T); if (NULL != v->parentEdge) { Rprintf ("Error: root %s is poorly rooted.\n",v->label); exit(0); } for(e = v->middleEdge, v->middleEdge = NULL; NULL != e; e = f ) { w = e->head; v = e->tail; e->tail = w; e->head = v; f = w->leftEdge; v->parentEdge = e; w->leftEdge = e; w->parentEdge = NULL; } T->root = w; return(T); }
void CPatcherWindow::UpdatePatcherStatus() { m_patchProgress.SetRange(0, m_patchPaths.size()); if(m_patchResult != PATCHER_SERVICE_RESULT_SUCCESS) { m_patchStatusLabel.SetText(_T("Patch failed.")); m_patchProgress.SetPosition(m_patchPaths.size()); m_patchProgress.SetState(PBST_ERROR); } else if(m_patchIdx == m_patchPaths.size()) { //Complete m_patchStatusLabel.SetText(_T("Complete!")); m_patchProgressLabel.SetText(_T("100%")); m_patchProgress.SetPosition(m_patchIdx); } else { auto nextPatchPath = m_patchPaths[m_patchIdx]; unsigned int patchPercent = static_cast<unsigned int>(static_cast<float>(m_patchIdx) / static_cast<float>(m_patchPaths.size()) * 100.f); m_patchProgress.SetPosition(m_patchIdx); m_patchStatusLabel.SetText(string_format(_T("Applying '%s'..."), nextPatchPath.leaf().native().c_str()).c_str()); m_patchProgressLabel.SetText(string_format(_T("%d%%"), patchPercent).c_str()); } }
static Tree * post(Lex *lxp) { Tree *lp; if ((lp = leaf(lxp)) == 0) return 0; switch (lxp->tok) { case ROP_EMPTY: /* this was {0,0} ROP_BRACE */ libuxre_regdeltree(lp, 1); lp = 0; /*FALLTHROUGH*/ case ROP_BRACE: case ROP_STAR: case ROP_PLUS: case ROP_QUEST: if ((lp = libuxre_reg1tree(lxp->tok, lp)) == 0) { lxp->err = REG_ESPACE; return 0; } if (lxp->tok == ROP_BRACE) lp->right.info = lxp->info; /*FALLTHROUGH*/ case ROP_NOP: /* this was {1,1} ROP_BRACE */ if (lex(lxp) != 0) { libuxre_regdeltree(lp, 1); return 0; } break; } return lp; }
// Converts a SyntaxNode tree to a Moses::GHKM::ParseTree. std::auto_ptr<ParseTree> XmlTreeParser::ConvertTree( const SyntaxNode &tree, const std::vector<std::string> &words) { std::auto_ptr<ParseTree> root(new ParseTree(tree.GetLabel())); const std::vector<SyntaxNode*> &children = tree.GetChildren(); if (children.empty()) { if (tree.GetStart() != tree.GetEnd()) { std::ostringstream msg; msg << "leaf node covers multiple words (" << tree.GetStart() << "-" << tree.GetEnd() << "): this is currently unsupported"; throw Exception(msg.str()); } std::auto_ptr<ParseTree> leaf(new ParseTree(words[tree.GetStart()])); leaf->SetParent(root.get()); root->AddChild(leaf.release()); } else { for (std::vector<SyntaxNode*>::const_iterator p = children.begin(); p != children.end(); ++p) { assert(*p); std::auto_ptr<ParseTree> child = ConvertTree(**p, words); child->SetParent(root.get()); root->AddChild(child.release()); } } return root; }
void NewickPrintTreeStr(tree *T, char *str) { if (leaf(T->root)) NewickPrintBinaryTree(T,str); else NewickPrintTrinaryTree(T,str); }
status_t WinampSkinThemesAddon::SPSkin(BString *to, bool preffile) { if (preffile) { status_t err; BMessage settings; BPath SPSPath; if (find_directory(B_USER_SETTINGS_DIRECTORY, &SPSPath) < B_OK) return B_ERROR; BString leaf(SP_SETTINGS_NAME); BString user(getenv("USER")); user.RemoveFirst("USER="******"$USER", user.String()); SPSPath.Append(leaf.String()); PRINT(("SPP %s\n", SPSPath.Path())); BFile SPSettings(SPSPath.Path(), B_READ_ONLY); if (SPSettings.InitCheck() < B_OK) return SPSettings.InitCheck(); if (settings.Unflatten(&SPSettings) < B_OK) return EIO; err = settings.FindString("skinname", to); StripPath(to); return err; } BMessenger msgr(SP_APP_SIG); BMessage msg('skin'); BMessage reply; msgr.SendMessage(&msg, (BHandler *)NULL, 500000); if (reply.FindString("result", to) >= B_OK) { StripPath(to); return B_OK; } return B_ERROR; }
std::auto_ptr<cpunit::TestRunner> cpunit::TestExecutionFacade::get_test_runner(const bool robust, const double max_time) const { std::auto_ptr<TestRunner> leaf(new BasicTestRunner); if (robust) { CPUNIT_ITRACE("TestExecutionFacade::get_test_runner - Returning robust TestRunner"); // For handling of extra, custom exceptions, insert your handler here, // and remember to modify the next decorator insertion... // std::auto_ptr<TestRunnerDecorator> d1(new MyCustomHandler); // d1->set_inner(leaf.release()); // Add a layer of exception handling over the executing test runner std::auto_ptr<TestRunnerDecorator> d2(new RunAllTestRunner); d2->set_inner(leaf.release()); // Add a layer of time taking std::auto_ptr<TestRunnerDecorator> d3(new TimeGuardRunner(max_time)); d3->set_inner(d2.release()); // Add a new layer of exception handling in case the max-time is exceeded std::auto_ptr<TestRunnerDecorator> d4(new RunAllTestRunner); d4->set_inner(d3.release()); return std::auto_ptr<TestRunner>(d4.release()); } else { CPUNIT_ITRACE("TestExecutionFacade::get_test_runner - Returning BasicTestRunner"); // Add a layer of time taking over the executing test runner std::auto_ptr<TestRunnerDecorator> d1(new TimeGuardRunner(max_time)); d1->set_inner(leaf.release()); return std::auto_ptr<TestRunner>(d1.release()); } }
list<int> suc_polytomy(int i,int j,Pr* pr,Node** nodes,int* & Pre,list<int> &suc){ list<int> result; if (leaf(nodes[i])) { nodes[j]->D=nodes[i]->D; activeMarkLeaf(nodes[j]); } if (j>=pr->nbINodes) { result.push_back(j); Pre[j]=i; if (markLeaf(nodes[j]) || j<pr->nbINodes) suc.push_back(j); } else{ for (vector<int>::iterator iter=nodes[j]->suc.begin(); iter!=nodes[j]->suc.end(); iter++) { int s=*iter; if (!tc(nodes[s])) { Pre[s]=i; if (markLeaf(nodes[s]) || s<pr->nbINodes) suc.push_back(s); } else{ list<int> l1=suc_polytomy(i,s,pr,nodes,Pre,suc); concatPos(l1,result); } } if (j!=i) result.push_back(j); } return result; }
std::vector< std::pair< prm::qualified_path, std::string > > get_available_agent_specs(prm::param_accessor param_vals) { std::vector< std::pair< prm::qualified_path, std::string > > names; auto node = param_vals["agent_spec_list"]; auto agent_spec_list_path = resolve_id("agent_spec_list", param_vals.get_root(), param_vals.get_current_path(), param_vals.get_all_paths()); for(auto agent_entry : node) { auto agent_repeat_num = agent_entry.first.as< unsigned int >(); auto agent = agent_entry.second; auto rel_path = prm::qualified_path({ "spec" }) + std::string{ "name" }; auto name_node = prm::find_value(agent, rel_path); assert(name_node); auto spec_path = agent_spec_list_path; spec_path.leaf().set_index(agent_repeat_num); spec_path += std::string("spec"); names.emplace_back(std::make_pair( spec_path, name_node.as< std::string >() )); } return names; }
bool param_tree::add_repeat_instance(tree_t::node_descriptor rpt_node, param_accessor acc, schema::schema_provider_map_handle sch_mp) { auto nd_attribs = m_tree[rpt_node]; if(nd_attribs.type != ParamType::Repeat) { return false; } // TODO: respect repeat max count auto inst_num = 0; bool first = m_tree.child_count(rpt_node) == 0; if(!first) { // Get the edge of the rightmost existing instance auto edge = m_tree.in_edge(m_tree.get_rightmost_child(rpt_node).first).first; // And add 1 to its instance number to generate the instance number of the new instance // Note: This assumes that instances cannot be repositioned once created. inst_num = *m_tree[edge].repeat_idx + 1; } auto instance = m_tree.add_node(rpt_node).second; m_tree[m_tree.in_edge(instance).first].repeat_idx = inst_num; auto path = node_qpath(rpt_node); path.leaf().set_index(inst_num); auto contents_name = boost::any_cast<repeat_extra>(m_tree[rpt_node].extra).contents_name; path += contents_name; //acc.set_lock_on_failed_move(true); acc.move_to(path); auto sch = sch_mp->at(path.unindexed())(acc); generate_from_schema(sch, instance, acc, sch_mp); return true; }
void CAGAppleExample::draw(IGrafPort& port) { // Start with an IGArea defining the left side of the apple. IGArea apple(IGEllipse2D(IGRect2D(0,64,96,176))); // Add in the right side of the apple. apple += IGEllipse2D(IGRect2D(32,64,128,176)); // And the apple stem. apple += IGRect2D(63,32,65,72); // Now, add the right leaf. IGArea leaf(IGEllipse2D(IGRect2D(40,16,88,64))); leaf *= IGEllipse2D(IGRect2D(64,40,112,88)); apple += leaf; // Flip the right leaf around and use it as the left leaf. leaf.transformBy(IGrafMatrix(IGPoint2D(-1,1), IGPoint2D(64,0))); leaf.transformBy(IGrafMatrix(IGPoint2D(0,-16))); apple += leaf; // Draw the result. port.draw(apple, IFillAndFrameBundle(kDefaultFillColor, kDefaultFrameColor, kDefaultPenWidth)); }
/*fillTableUp fills all the entries in D associated with e->head,f->head and those edges g->head above e->head*/ void fillTableUp(edge *e, edge *f, double **A, double **D, tree *T) { edge *g,*h; if (T->root == f->tail) { if (leaf(e->head)) A[e->head->index][f->head->index] = A[f->head->index][e->head->index] = D[e->head->index2][f->tail->index2]; else { g = e->head->leftEdge; h = e->head->rightEdge; A[e->head->index][f->head->index] = A[f->head->index][e->head->index] = (g->bottomsize*A[f->head->index][g->head->index] + h->bottomsize*A[f->head->index][h->head->index]) /e->bottomsize; } } else { g = f->tail->parentEdge; fillTableUp(e,g,A,D,T); /*recursive call*/ h = siblingEdge(f); A[e->head->index][f->head->index] = A[f->head->index][e->head->index] = (g->topsize*A[e->head->index][g->head->index] + h->bottomsize*A[e->head->index][h->head->index])/f->topsize; } }
nsresult GetAvailableRuntime(nsILocalFile* *_retval) { NS_ENSURE_ARG_POINTER(_retval); nsresult rv = NS_ERROR_FAILURE; // Get the path of the GRE which is compatible with our embedding application // from the registry const char *pGREDir = GetAvailableRuntime (); if(!pGREDir) return NS_ERROR_FAILURE; nsCOMPtr<nsILocalFile> xpcomPath; nsEmbedCString leaf(pGREDir); rv = NS_NewNativeLocalFile(leaf, PR_TRUE, getter_AddRefs(xpcomPath)); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIFile> directory; rv = xpcomPath->GetParent(getter_AddRefs(directory)); if (NS_FAILED(rv)) return rv; return CallQueryInterface(directory, _retval); }
status_t WinampSkinThemesAddon::SPSkinPath(BPath *to) { status_t err; BMessage settings; BPath SPSPath; BString str; if (find_directory(B_USER_SETTINGS_DIRECTORY, &SPSPath) < B_OK) return B_ERROR; BString leaf(SP_SETTINGS_NAME); BString user(getenv("USER")); user.RemoveFirst("USER="******"$USER", user.String()); SPSPath.Append(leaf.String()); BFile SPSettings(SPSPath.Path(), B_READ_ONLY); if (SPSettings.InitCheck() < B_OK) return SPSettings.InitCheck(); if (settings.Unflatten(&SPSettings) < B_OK) return EIO; err = settings.FindString("skinpath", &str); PRINT(("SPSP %s\n", str.String())); to->SetTo(str.String()); return err; }
/** * Create if missing a Maildir-style folder with "tmp" and "cur" subfolders * but no "new" subfolder, because it doesn't make sense in the mail client * context. ("new" directory is for messages on the server that haven't been * seen by a mail client). * aFolderName is already "safe" - it has been through NS_MsgHashIfNecessary. */ nsresult nsMsgMaildirStore::CreateMaildir(nsIFile *path) { nsresult rv = path->Create(nsIFile::DIRECTORY_TYPE, 0700); if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) { NS_WARNING("Could not create root directory for message folder"); return rv; } // Create tmp, cur leaves nsCOMPtr<nsIFile> leaf(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); leaf->InitWithFile(path); leaf->AppendNative(NS_LITERAL_CSTRING("tmp")); rv = leaf->Create(nsIFile::DIRECTORY_TYPE, 0700); if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) { NS_WARNING("Could not create tmp directory for message folder"); return rv; } leaf->SetNativeLeafName(NS_LITERAL_CSTRING("cur")); rv = leaf->Create(nsIFile::DIRECTORY_TYPE, 0700); if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) { NS_WARNING("Could not create cur directory for message folder"); return rv; } return NS_OK; }
static PRBool CopyFileIntoUpdateDir(nsIFile *parentDir, const char *leafName, nsIFile *updateDir) { nsDependentCString leaf(leafName); nsCOMPtr<nsIFile> file; // Make sure there is not an existing file in the target location. nsresult rv = updateDir->Clone(getter_AddRefs(file)); if (NS_FAILED(rv)) return PR_FALSE; rv = file->AppendNative(leaf); if (NS_FAILED(rv)) return PR_FALSE; file->Remove(PR_FALSE); // Now, copy into the target location. rv = parentDir->Clone(getter_AddRefs(file)); if (NS_FAILED(rv)) return PR_FALSE; rv = file->AppendNative(leaf); if (NS_FAILED(rv)) return PR_FALSE; rv = file->CopyToNative(updateDir, EmptyCString()); if (NS_FAILED(rv)) return PR_FALSE; return PR_TRUE; }
forceinline long long int ExtOmegaTree<TaskView>::env(int i) { // Enter task i leaf(i).e = tasks[i].e(); leaf(i).env = static_cast<long long int>(c)*tasks[i].est()+tasks[i].e(); leaf(i).cenv = static_cast<long long int>(c-ci)*tasks[i].est()+tasks[i].e(); TaskTree<TaskView,ExtOmegaNode>::update(i); // Perform computation of node for task with minest int met = 0; { long long int e = 0; while (!n_leaf(met)) { if (plus(node[n_right(met)].cenv,e) > static_cast<long long int>(c-ci) * tasks[i].lct()) { met = n_right(met); } else { e += node[n_right(met)].e; met = n_left(met); } } } /* * The following idea to compute the cut in one go is taken from: * Joseph Scott, Filtering Algorithms for Discrete Resources, * Master Thesis, Uppsala University, 2010 (in preparation). */ // Now perform split from leaf met upwards long long int a_e = node[met].e; long long int a_env = node[met].env; long long int b_e = 0; while (!n_root(met)) { if (left(met)) { b_e += node[n_right(n_parent(met))].e; } else { a_env = std::max(a_env, plus(node[n_left(n_parent(met))].env,a_e)); a_e += node[n_left(n_parent(met))].e; } met = n_parent(met); } return plus(a_env,b_e); }
PriorityQueue emptyPriorityQueue(){ PriorityQueue newPQ = new PriorityQueueStr; newPQ -> totalSize = 256; // Hardcodeo 256 porque estamos trabajando con codificacion ASCII y la máxima cantidad posible de elementos diferentes es 256. newPQ -> elements = new HuffmanTree[newPQ -> totalSize + 1]; newPQ -> actualSize = 0; newPQ -> elements[0] = leaf('x',0); // Necesito quedarme con la posicion 0 para guardar el elemento más prioritario allí. return newPQ; }