How to use

HeapSelect

in

smile.sort

@SuppressWarnings("unchecked")
SimpleNeighbor<T>[] neighbors = (SimpleNeighbor<T>[]) java.lang.reflect.Array.newInstance(neighbor.getClass(), k);
HeapSelect<Neighbor<T,T>> heap = new HeapSelect<>(neighbors);
for (int i = 0; i < k; i++) {
  heap.add(neighbor);
  neighbor = new SimpleNeighbor<>(null, 0, Double.MAX_VALUE);
  Neighbor<T,T> datum = heap.peek();
  if (dist < datum.distance) {
    datum.distance = dist;
    datum.key = data[i];
    datum.value = data[i];
    heap.heapify();
heap.sort();
return neighbors;

HeapSelect<Neighbor> heap = new HeapSelect<>(neighbors);
          if (heap.peek() == null || distance < heap.peek().distance) {
            heap.add(new Neighbor(e.neuron, distance));
            hit++;

@Override
public Neighbor<double[], E>[] knn(double[] q, int k) {
  if (k <= 0) {
    throw new IllegalArgumentException("Invalid k: " + k);
  }
  if (k > keys.length) {
    throw new IllegalArgumentException("Neighbor array length is larger than the dataset size");
  }
  Neighbor<double[], E> neighbor = new Neighbor<>(null, null, 0, Double.MAX_VALUE);
  @SuppressWarnings("unchecked")
  Neighbor<double[], E>[] neighbors = (Neighbor<double[], E>[]) java.lang.reflect.Array.newInstance(neighbor.getClass(), k);
  HeapSelect<Neighbor<double[], E>> heap = new HeapSelect<>(neighbors);
  for (int i = 0; i < k; i++) {
    heap.add(neighbor);
    neighbor = new Neighbor<>(null, null, 0, Double.MAX_VALUE);
  }
  search(q, root, heap);
  heap.sort();
  for (int i = 0; i < neighbors.length; i++) {
    neighbors[i].distance = Math.sqrt(neighbors[i].distance);
  }
  return neighbors;
}

  Neighbor<double[], E> datum = heap.peek();
  if (distance < datum.distance) {
    datum.distance = distance;
    datum.key = keys[index[idx]];
    datum.value = data[index[idx]];
    heap.heapify();
if (heap.peek().distance >= diff * diff) {
  search(q, further, heap);

/**
 * Sort the smallest values.
 */
public void sort() {
  if (!sorted) {
    sort(heap, Math.min(k,n));
    sorted = true;
  }
}

/**
 * Assimilate a new value from the stream.
 */
public void add(T datum) {
  sorted = false;
  if (n < k) {
    heap[n++] = datum;
    if (n == k) {
      heapify(heap);
    }
  } else {
    n++;
    if (datum.compareTo(heap[0]) < 0) {
      heap[0] = datum;
      SortUtils.siftDown(heap, 0, k-1);
    }
  }
}

HeapSelect<Node> heap = new HeapSelect<>(top2);
for (Node neuron : nodes) {
  neuron.dist = Math.squaredDistance(neuron.w, x);
  heap.add(neuron);

/**
 * Returns the i-<i>th</i> smallest value seen so far. i = 0 returns the smallest
 * value seen, i = 1 the second largest, ..., i = k-1 the last position
 * tracked. Also, i must be less than the number of previous assimilated.
 */
public T get(int i) {
  if (i > Math.min(k, n) - 1) {
    throw new IllegalArgumentException("HeapSelect i is greater than the number of data received so far.");
  }
  if (i == k-1) {
    return heap[0];
  }
  
  if (!sorted) {
    sort(heap, Math.min(k,n));
    sorted = true;
  }
  return heap[k-1-i];
}

@SuppressWarnings("unchecked")
Neighbor<double[], E>[] neighbors = (Neighbor<double[], E>[]) java.lang.reflect.Array.newInstance(neighbor.getClass(), k);
HeapSelect<Neighbor<double[], E>> heap = new HeapSelect<>(neighbors);
for (int i = 0; i < k; i++) {
  heap.add(neighbor);
  if (distance < heap.peek().distance) {
    heap.add(new Neighbor<>(key, data.get(index), index, distance));
    hit++;
heap.sort();

HeapSelect<Neighbor<AbstractSentence, E>> heap = new HeapSelect<>(neighbors);
Neighbor<AbstractSentence, E> neighbor = new Neighbor<>(null, null, 0, Double.MAX_VALUE);
for (int i = 0; i < k; i++) {
  heap.add(neighbor);
  if (distance < heap.peek().distance) {
    heap.add(new Neighbor<>(keys.get(index), data.get(index), index, distance));
    hit++;
heap.sort();
if (hit < k) {
  Neighbor<AbstractSentence, E>[] n2 = (Neighbor<AbstractSentence, E>[])Array.newInstance(Neighbor.class, hit);

@SuppressWarnings("unchecked")
Neighbor<double[], E>[] neighbors = (Neighbor<double[], E>[]) java.lang.reflect.Array.newInstance(neighbor.getClass(), k);
HeapSelect<Neighbor<double[], E>> heap = new HeapSelect<>(neighbors);
for (int i = 0; i < k; i++) {
  heap.add(neighbor);
  if (dist < heap.peek().distance) {
    heap.add(new Neighbor<>(key, data.get(index), index, dist));
    hit++;
heap.sort();