@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; }
/** * 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();