void write_viminfo_filemarks(FILE *fp) { int i; char_u *name; buf_T *buf; xfmark_T *fm; if (get_viminfo_parameter('f') == 0) return; fputs(_("\n# File marks:\n"), fp); /* * Find a mark that is the same file and position as the cursor. * That one, or else the last one is deleted. * Move '0 to '1, '1 to '2, etc. until the matching one or '9 * Set '0 mark to current cursor position. */ if (curbuf->b_ffname != NULL && !removable(curbuf->b_ffname)) { name = buflist_nr2name(curbuf->b_fnum, TRUE, FALSE); for (i = NMARKS; i < NMARKS + EXTRA_MARKS - 1; ++i) if (namedfm[i].fmark.mark.lnum == curwin->w_cursor.lnum && (namedfm[i].fname == NULL ? namedfm[i].fmark.fnum == curbuf->b_fnum : (name != NULL && STRCMP(name, namedfm[i].fname) == 0))) break; vim_free(name); vim_free(namedfm[i].fname); for (; i > NMARKS; --i) namedfm[i] = namedfm[i - 1]; namedfm[NMARKS].fmark.mark = curwin->w_cursor; namedfm[NMARKS].fmark.fnum = curbuf->b_fnum; namedfm[NMARKS].fname = NULL; } /* Write the filemarks '0 - '9 and 'A - 'Z */ for (i = 0; i < NMARKS + EXTRA_MARKS; i++) write_one_filemark(fp, &namedfm[i], '\'', i < NMARKS ? i + 'A' : i - NMARKS + '0'); /* Write the jumplist with -' */ fputs(_("\n# Jumplist (newest first):\n"), fp); setpcmark(); /* add current cursor position */ cleanup_jumplist(); for (fm = &curwin->w_jumplist[curwin->w_jumplistlen - 1]; fm >= &curwin->w_jumplist[0]; --fm) { if (fm->fmark.fnum == 0 || ((buf = buflist_findnr(fm->fmark.fnum)) != NULL && !removable(buf->b_ffname))) write_one_filemark(fp, fm, '-', '\''); } }
/* * Write all the named marks for all buffers. * Return the number of buffers for which marks have been written. */ int write_viminfo_marks(FILE *fp_out) { int count; buf_T *buf; int is_mark_set; int i; win_T *win; tabpage_T *tp; /* * Set b_last_cursor for the all buffers that have a window. */ FOR_ALL_TAB_WINDOWS(tp, win) set_last_cursor(win); fputs(_("\n# History of marks within files (newest to oldest):\n"), fp_out); count = 0; for (buf = firstbuf; buf != NULL; buf = buf->b_next) { /* * Only write something if buffer has been loaded and at least one * mark is set. */ if (buf->b_marks_read) { if (buf->b_last_cursor.lnum != 0) is_mark_set = TRUE; else { is_mark_set = FALSE; for (i = 0; i < NMARKS; i++) if (buf->b_namedm[i].lnum != 0) { is_mark_set = TRUE; break; } } if (is_mark_set && buf->b_ffname != NULL && buf->b_ffname[0] != NUL && !removable(buf->b_ffname)) { home_replace(NULL, buf->b_ffname, IObuff, IOSIZE, TRUE); fprintf(fp_out, "\n> "); viminfo_writestring(fp_out, IObuff); write_one_mark(fp_out, '"', &buf->b_last_cursor); write_one_mark(fp_out, '^', &buf->b_last_insert); write_one_mark(fp_out, '.', &buf->b_last_change); /* changelist positions are stored oldest first */ for (i = 0; i < buf->b_changelistlen; ++i) write_one_mark(fp_out, '+', &buf->b_changelist[i]); for (i = 0; i < NMARKS; i++) write_one_mark(fp_out, 'a' + i, &buf->b_namedm[i]); count++; } } } return count; }
int max_removable(vector<vector<int> > neighbors, vector<int> cover) { int r=-1, max=-1; for(int i=0; i<cover.size(); i++) { if(cover[i]==1 && removable(neighbors[i],cover)==true) { vector<int> temp_cover=cover; temp_cover[i]=0; int sum=0; for(int j=0; j<temp_cover.size(); j++) if(temp_cover[j]==1 && removable(neighbors[j], temp_cover)==true) sum++; if(sum>max) { max=sum; r=i; } } } return r; }
static void cleanupNode(Process::MessageNode& rootNode) { for(auto it = rootNode.begin(); it != rootNode.end(); ) { auto& child = *it; if(removable(child)) { it = rootNode.erase(it); } else { it++; } } }
// implementation of RE algorithm bool REDiscard::reduceSpheres(Array<int> *inds, int maxNum, Array<int> *destCounts, double maxMet, Array<double> *mets) const{ // get points const Array<Surface::Point> *surPts = surRep->getSurPts(); int numPts = surPts->getSize(); int numSph = srcSpheres->getSize(); // list of counts for number of spheres over each point Array<int> pointCounts(numPts), sphereCount(numSph); pointCounts.clear(); // fill list Array<bool> coveredPts(numPts); coveredPts.clear(); for (int i = 0; i < numSph; i++){ Array<int> list; surRep->listContainedPoints(&list, &coveredPts, srcSpheres->index(i)); int numList = list.getSize(); for (int j = 0; j < numList; j++){ int pI = list.index(j); pointCounts.index(pI)++; } sphereCount.index(i) = numList; } // no point continuing if the points aren't all covered to start for (int i = 0; i < numPts; i++) if (!coveredPts.index(i)) return false; // make list of spheres that are removable Array<bool> removable(numSph); for (int i = 0; i < numSph; i++) removable.index(i) = isSphereRemovable(pointCounts, i); // flags for which spheres have been dumped Array<bool> removed(numSph); removed.clear(); // do reduction while (true){ // find "smallest" removable sphere int minI = -1; int minCount = INT_MAX; for (int i = 0; i < numSph; i++){ if (removable.index(i)){ int count = sphereCount.index(i); if (count < minCount){ minCount = count; minI = i; } } } // did we find a removable sphere if (minI < 0) break; OUTPUTINFO("Discarding Sphere %d\n", minI); // remove sphere removed.index(minI) = true; removable.index(minI) = false; // decrement counts for number of spheres covering the points Array<int> list; surRep->listContainedPoints(&list, NULL, srcSpheres->index(minI)); int numList = list.getSize(); for (int i = 0; i < numList; i++){ int pI = list.index(i); pointCounts.index(pI)--; } // check the spheres for removability for (int i = 0; i < numSph; i++){ bool *flag = &removable.index(i); if ((*flag) == true){ (*flag) = isSphereRemovable(pointCounts, i); } } } // generate indices inds->setSize(0); for (int i = 0; i < numSph; i++){ if (!removed.index(i)) inds->addItem() = i; } OUTPUTINFO("%d Spheres left\n", inds->getSize()); return (maxNum < 0) || (inds->getSize() <= maxNum); }