public FloatIteratorNode Add(FloatIteratorNode element) { size++; heap[size] = element; UpHeap(); return(heap[1]); }
public override float NextFloat() { if (!HasNext()) { throw new IndexOutOfRangeException("No more facets in this iteration"); } FloatIteratorNode node = _queue.Top(); _facet = node.CurFacet; float next = TermFloatList.VALUE_MISSING; count = 0; while (HasNext()) { node = _queue.Top(); next = node.CurFacet; if ((next != TermFloatList.VALUE_MISSING) && (next != _facet)) { return(_facet); } count += node.CurFacetCount; if (node.Fetch(1)) { _queue.UpdateTop(); } else { _queue.Pop(); } } return(TermFloatList.VALUE_MISSING); }
/// <summary> /// This version of the next() method applies the minHits from the facet spec /// before returning the facet and its hitcount /// </summary> /// <param name="minHits">the minHits from the facet spec for CombinedFacetAccessible</param> /// <returns>The next facet that obeys the minHits</returns> public override string Next(int minHits) { int qsize = _queue.Size(); if (qsize == 0) { _facet = TermFloatList.VALUE_MISSING; count = 0; return(null); } FloatIteratorNode node = _queue.Top(); _facet = node.CurFacet; count = node.CurFacetCount; while (true) { if (node.Fetch(minHits)) { node = _queue.UpdateTop(); } else { _queue.Pop(); if (--qsize > 0) { node = _queue.Top(); } else { // we reached the end. check if this facet obeys the minHits if (count < minHits) { _facet = TermFloatList.VALUE_MISSING; count = 0; return(null); } break; } } float next = node.CurFacet; if (next != _facet) { // check if this facet obeys the minHits if (count >= minHits) { break; } // else, continue iterating to the next facet _facet = next; count = node.CurFacetCount; } else { count += node.CurFacetCount; } } return(Format(_facet)); }
private void UpHeap() { int i = size; FloatIteratorNode node = heap[i]; // save bottom node int j = (int)(((uint)i) >> 1); while (j > 0 && (node.CurFacet < heap[j].CurFacet)) { heap[i] = heap[j]; // shift parents down i = j; j = (int)(((uint)j) >> 1); } heap[i] = node; // install saved node }
public CombinedFloatFacetIterator(IList <FloatFacetIterator> iterators, int minHits) : this(iterators.Count) { _iterators = iterators; foreach (FloatFacetIterator iterator in iterators) { FloatIteratorNode node = new FloatIteratorNode(iterator); if (node.Fetch(minHits)) { _queue.Add(node); } } _facet = TermFloatList.VALUE_MISSING; count = 0; }
/// <summary> /// Removes and returns the least element of the PriorityQueue in /// log(size) time. /// </summary> /// <returns></returns> public FloatIteratorNode Pop() { if (size > 0) { FloatIteratorNode result = heap[1]; // save first value heap[1] = heap[size]; // move last to first heap[size] = null; // permit GC of objects size--; DownHeap(); // adjust heap return(result); } else { return(null); } }
public virtual FloatIteratorNode InsertWithOverflow(FloatIteratorNode element) { if (size < maxSize) { Put(element); return(null); } else if (size > 0 && !(element.CurFacet < heap[1].CurFacet)) { FloatIteratorNode ret = heap[1]; heap[1] = element; AdjustTop(); return(ret); } else { return(element); } }
private void DownHeap() { int i = 1; FloatIteratorNode node = heap[i]; // save top node int j = i << 1; // find smaller child int k = j + 1; if (k <= size && (heap[k].CurFacet < heap[j].CurFacet)) { j = k; } while (j <= size && (heap[j].CurFacet < node.CurFacet)) { heap[i] = heap[j]; // shift up child i = j; j = i << 1; k = j + 1; if (k <= size && (heap[k].CurFacet < heap[j].CurFacet)) { j = k; } } heap[i] = node; // install saved node }
public virtual bool Insert(FloatIteratorNode element) { return(InsertWithOverflow(element) != element); }
public void Put(FloatIteratorNode element) { size++; heap[size] = element; UpHeap(); }
public CombinedFloatFacetIterator(IList<FloatFacetIterator> iterators, int minHits) : this(iterators.Count) { _iterators = iterators; foreach (FloatFacetIterator iterator in iterators) { FloatIteratorNode node = new FloatIteratorNode(iterator); if (node.Fetch(minHits)) _queue.Add(node); } _facet = TermFloatList.VALUE_MISSING; count = 0; }
public virtual FloatIteratorNode InsertWithOverflow(FloatIteratorNode element) { if (size < maxSize) { Put(element); return null; } else if (size > 0 && !(element.CurFacet < heap[1].CurFacet)) { FloatIteratorNode ret = heap[1]; heap[1] = element; AdjustTop(); return ret; } else { return element; } }
public virtual bool Insert(FloatIteratorNode element) { return InsertWithOverflow(element) != element; }
public FloatIteratorNode Add(FloatIteratorNode element) { size++; heap[size] = element; UpHeap(); return heap[1]; }