public override float NextSingle() { if (!HasNext()) { throw new IndexOutOfRangeException("No more facets in this iteration"); } SingleIteratorNode node = m_queue.Top; m_facet = node.CurFacet; float next = TermSingleList.VALUE_MISSING; m_count = 0; while (HasNext()) { node = m_queue.Top; next = node.CurFacet; if ((next != TermSingleList.VALUE_MISSING) && (next != m_facet)) { return(m_facet); } m_count += node.CurFacetCount; if (node.Fetch(1)) { m_queue.UpdateTop(); } else { m_queue.Pop(); } } return(TermSingleList.VALUE_MISSING); }
public SingleIteratorNode Add(SingleIteratorNode element) { m_size++; m_heap[m_size] = element; UpHeap(); return(m_heap[1]); }
/// <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 = m_queue.Count; if (qsize == 0) { m_facet = TermSingleList.VALUE_MISSING; m_count = 0; return(null); } SingleIteratorNode node = m_queue.Top; m_facet = node.CurFacet; m_count = node.CurFacetCount; while (true) { if (node.Fetch(minHits)) { node = m_queue.UpdateTop(); } else { m_queue.Pop(); if (--qsize > 0) { node = m_queue.Top; } else { // we reached the end. check if this facet obeys the minHits if (m_count < minHits) { m_facet = TermSingleList.VALUE_MISSING; m_count = 0; return(null); } break; } } float next = node.CurFacet; if (next != m_facet) { // check if this facet obeys the minHits if (m_count >= minHits) { break; } // else, continue iterating to the next facet m_facet = next; m_count = node.CurFacetCount; } else { m_count += node.CurFacetCount; } } return(Format(m_facet)); }
private void UpHeap() { int i = m_size; SingleIteratorNode node = m_heap[i]; // save bottom node int j = (int)(((uint)i) >> 1); while (j > 0 && (node.CurFacet < m_heap[j].CurFacet)) { m_heap[i] = m_heap[j]; // shift parents down i = j; j = (int)(((uint)j) >> 1); } m_heap[i] = node; // install saved node }
public CombinedSingleFacetIterator(IList <SingleFacetIterator> iterators, int minHits) : this(iterators.Count) { m_iterators = iterators; foreach (SingleFacetIterator iterator in iterators) { SingleIteratorNode node = new SingleIteratorNode(iterator); if (node.Fetch(minHits)) { m_queue.Add(node); } } m_facet = TermSingleList.VALUE_MISSING; m_count = 0; }
/// <summary> /// Removes and returns the least element of the PriorityQueue in /// log(size) time. /// </summary> /// <returns></returns> public SingleIteratorNode Pop() { if (m_size > 0) { SingleIteratorNode result = m_heap[1]; // save first value m_heap[1] = m_heap[m_size]; // move last to first m_heap[m_size] = null; // permit GC of objects m_size--; DownHeap(); // adjust heap return(result); } else { return(null); } }
public virtual SingleIteratorNode InsertWithOverflow(SingleIteratorNode element) { if (m_size < m_maxSize) { Put(element); return(null); } else if (m_size > 0 && !(element.CurFacet < m_heap[1].CurFacet)) { SingleIteratorNode ret = m_heap[1]; m_heap[1] = element; AdjustTop(); return(ret); } else { return(element); } }
private void DownHeap() { int i = 1; SingleIteratorNode node = m_heap[i]; // save top node int j = i << 1; // find smaller child int k = j + 1; if (k <= m_size && (m_heap[k].CurFacet < m_heap[j].CurFacet)) { j = k; } while (j <= m_size && (m_heap[j].CurFacet < node.CurFacet)) { m_heap[i] = m_heap[j]; // shift up child i = j; j = i << 1; k = j + 1; if (k <= m_size && (m_heap[k].CurFacet < m_heap[j].CurFacet)) { j = k; } } m_heap[i] = node; // install saved node }
public virtual bool Insert(SingleIteratorNode element) { return(InsertWithOverflow(element) != element); }
public void Put(SingleIteratorNode element) { m_size++; m_heap[m_size] = element; UpHeap(); }