Java Code Examples for java.util.PriorityQueue#size()

The following examples show how to use java.util.PriorityQueue#size() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
/**
 * Determine the k nearest neighbors for a test instance.
 *
 * @param testInstance
 *            The time series to determine the k nearest neighbors for.
 * @return Queue of the k nearest neighbors as pairs (class, distance).
 */
protected PriorityQueue<Pair<Integer, Double>> calculateNearestNeigbors(final double[] testInstance) {
	int numberOfTrainInstances = this.values.length;
	// Priority queue of (class, distance)-pairs for nearest neigbors, sorted by
	// distance ascending.
	PriorityQueue<Pair<Integer, Double>> nearestNeighbors = new PriorityQueue<>(nearestNeighborComparator);

	// Calculate the k nearest neighbors.
	for (int i = 0; i < numberOfTrainInstances; i++) {
		double d = this.distanceMeasure.distance(testInstance, this.values[i]);

		Pair<Integer, Double> neighbor = new Pair<>(this.targets[i], d);
		nearestNeighbors.add(neighbor);
		if (nearestNeighbors.size() > this.k) {
			nearestNeighbors.poll();
		}
	}
	return nearestNeighbors;
}
 
Example 2
private List<Recognition> getRecognition(final PriorityQueue<Recognition> priorityQueue) {
    List<Recognition> recognitions = new ArrayList();

    if (priorityQueue.size() > 0) {
        // Best recognition
        Recognition bestRecognition = priorityQueue.poll();
        recognitions.add(bestRecognition);

        for (int i = 0; i < Math.min(priorityQueue.size(), MAX_RESULTS); ++i) {
            Recognition recognition = priorityQueue.poll();
            boolean overlaps = false;
            for (Recognition previousRecognition : recognitions) {
                overlaps = overlaps || (getIntersectionProportion(previousRecognition.getLocation(),
                        recognition.getLocation()) > OVERLAP_THRESHOLD);
            }

            if (!overlaps) {
                recognitions.add(recognition);
            }
        }
    }

    return recognitions;
}
 
Example 3
Source Project: j2objc   File: PriorityQueueTest.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * java.util.PriorityQueue#PriorityQueue(Collection)
 */
public void test_ConstructorLjava_util_Colleciton_from_priorityqueue() {
    String[] array = { "AAAAA", "AA", "AAAA", "AAAAAAAA" };
    PriorityQueue<String> queue = new PriorityQueue<String>(4,
            new MockComparatorStringByLength());
    for (int i = 0; i < array.length; i++) {
        queue.offer(array[i]);
    }
    Collection<String> c = queue;
    PriorityQueue<String> constructedQueue = new PriorityQueue<String>(c);
    assertEquals(queue.comparator(), constructedQueue.comparator());
    while (queue.size() > 0) {
        assertEquals(queue.poll(), constructedQueue.poll());
    }
    assertEquals(0, constructedQueue.size());
}
 
Example 4
Source Project: AMC   File: AMC.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Get the top words under each topic given current Markov status.
 */
private ArrayList<PriorityQueue<Integer>> getTopWordsUnderEachTopicGivenCurrentMarkovStatus() {
	ArrayList<PriorityQueue<Integer>> topWordIDList = new ArrayList<PriorityQueue<Integer>>();
	int top_words = param.numberOfTopWordsUnderPriorTopicsForKnowledgeExtraction;

	for (int t = 0; t < param.T; ++t) {
		Comparator<Integer> comparator = new TopicalWordComparator(phi[t]);
		PriorityQueue<Integer> pqueue = new PriorityQueue<Integer>(
				top_words, comparator);

		for (int w = 0; w < param.V; ++w) {
			if (pqueue.size() < top_words) {
				pqueue.add(w);
			} else {
				if (phi[t][w] > phi[t][pqueue.peek()]) {
					pqueue.poll();
					pqueue.add(w);
				}
			}
		}

		topWordIDList.add(pqueue);
	}
	return topWordIDList;
}
 
Example 5
Source Project: incubator-pinot   File: TableResizer.java    License: Apache License 2.0 6 votes vote down vote up
private PriorityQueue<IntermediateRecord> convertToIntermediateRecordsPQ(Map<Key, Record> recordsMap, int size,
    Comparator<IntermediateRecord> comparator) {
  PriorityQueue<IntermediateRecord> priorityQueue = new PriorityQueue<>(size, comparator);

  for (Map.Entry<Key, Record> entry : recordsMap.entrySet()) {

    IntermediateRecord intermediateRecord = getIntermediateRecord(entry.getKey(), entry.getValue());
    if (priorityQueue.size() < size) {
      priorityQueue.offer(intermediateRecord);
    } else {
      IntermediateRecord peek = priorityQueue.peek();
      if (comparator.compare(peek, intermediateRecord) < 0) {
        priorityQueue.poll();
        priorityQueue.offer(intermediateRecord);
      }
    }
  }
  return priorityQueue;
}
 
Example 6
private List<Recognition> getRecognition(final PriorityQueue<Recognition> priorityQueue) {
    List<Recognition> recognitions = new ArrayList();

    if (priorityQueue.size() > 0) {
        // Best recognition
        Recognition bestRecognition = priorityQueue.poll();
        recognitions.add(bestRecognition);

        for (int i = 0; i < Math.min(priorityQueue.size(), MAX_RESULTS); ++i) {
            Recognition recognition = priorityQueue.poll();
            boolean overlaps = false;
            for (Recognition previousRecognition : recognitions) {
                overlaps = overlaps || (getIntersectionProportion(previousRecognition.getLocation(),
                        recognition.getLocation()) > OVERLAP_THRESHOLD);
            }

            if (!overlaps) {
                recognitions.add(recognition);
            }
        }
    }

    return recognitions;
}
 
Example 7
Source Project: MediaSDK   File: AsyncServer.java    License: Apache License 2.0 5 votes vote down vote up
private static void run(final AsyncServer server, final SelectorWrapper selector, final PriorityQueue<Scheduled> queue) {
//        Log.i(LOGTAG, "****AsyncServer is starting.****");
        // at this point, this local queue and selector are owned
        // by this thread.
        // if a stop is called, the instance queue and selector
        // will be replaced and nulled respectively.
        // this will allow the old queue and selector to shut down
        // gracefully, while also allowing a new selector thread
        // to start up while the old one is still shutting down.
        while(true) {
            try {
                runLoop(server, selector, queue);
            }
            catch (AsyncSelectorException e) {
                if (!(e.getCause() instanceof ClosedSelectorException))
                    Log.i(LOGTAG, "Selector exception, shutting down", e);
                StreamUtility.closeQuietly(selector);
            }
            // see if we keep looping, this must be in a synchronized block since the queue is accessed.
            synchronized (server) {
                if (selector.isOpen() && (selector.keys().size() > 0 || queue.size() > 0))
                    continue;

                shutdownEverything(selector);
                if (server.mSelector == selector) {
                    server.mQueue = new PriorityQueue<Scheduled>(1, Scheduler.INSTANCE);
                    server.mSelector = null;
                    server.mAffinity = null;
                }
                break;
            }
        }
//        Log.i(LOGTAG, "****AsyncServer has shut down.****");
    }
 
Example 8
Source Project: GraphJet   File: SalsaSelectResults.java    License: Apache License 2.0 5 votes vote down vote up
private void addResultToPriorityQueue(
    PriorityQueue<NodeInfo> topResults,
    NodeInfo nodeInfo,
    int maxNumResults) {
  if (topResults.size() < maxNumResults) {
    topResults.add(nodeInfo);
  } else if (nodeInfo.getWeight() > topResults.peek().getWeight()) {
    topResults.poll();
    topResults.add(nodeInfo);
  }
}
 
Example 9
public int findKthLargest(int[] nums, int k) {
    int len = nums.length;
    // 最小堆
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(k + 1, (a, b) -> (a - b));
    for (int num : nums) {
        priorityQueue.add(num);
        if (priorityQueue.size() == k + 1) {
            priorityQueue.poll();
        }
    }
    return priorityQueue.peek();
}
 
Example 10
private void testCustomAggregation(Double[] values, int n)
{
    PriorityQueue<Double> heap = new PriorityQueue<>(n, (x, y) -> -Double.compare(x, y));
    Arrays.stream(values).filter(x -> x != null).forEach(heap::add);
    Double[] expected = new Double[heap.size()];
    for (int i = heap.size() - 1; i >= 0; i--) {
        expected[i] = heap.remove();
    }
    testAggregation(Arrays.asList(expected), createDoublesBlock(values), createLongRepeatBlock(n, values.length));
}
 
Example 11
Source Project: AsyncSocket   File: SocketServer.java    License: MIT License 5 votes vote down vote up
private static void run(final SocketServer server, final SelectorWrapper selector, final PriorityQueue<Scheduled> queue) {
    log("****SocketServer is starting.****");
    // at this point, this local queue and selector are owned by this thread.
    // if a stop is called, the instance queue and selector
    // will be replaced and nulled respectively.
    // this will allow the old queue and selector to shut down
    // gracefully, while also allowing a new selector thread
    // to start up while the old one is still shutting down.
    while (true) {
        try {
            runLoop(server, selector, queue);
        } catch (AsyncSelectorException e) {
            log("Selector exception, shutting down", e);
            try {
                // Util.closeQuiety is throwing ArrayStoreException?
                selector.getSelector().close();
            } catch (Exception ignore) {
            }
        }
        // see if we keep looping, this must be in a synchronized block since the queue is accessed.
        synchronized (server) {
            if (selector.isOpen() && (selector.keys().size() > 0 || queue.size() > 0))
                continue;

            shutdownEverything(selector);
            if (server.mSelector == selector) {
                server.mQueue = new PriorityQueue<Scheduled>(1, Scheduler.INSTANCE);
                server.mSelector = null;
                server.serverThread = null;
            }
            break;
        }
    }
    synchronized (servers) {
        servers.remove(Thread.currentThread());
    }
    log("****SocketServer has shut down.****");
}
 
Example 12
/**
 * Add a neighborInfo to the priority queue when the queue is not full
 * or the score of this neighborInfo is larger then the smallest score in the queue.
 *
 * @param topResults                the priority queue
 * @param neighborInfo              the neighborInfo to be added
 * @param maxNumResults             the maximum capacity of the queue
 */
private void addResultToPriorityQueue(
    PriorityQueue<NeighborInfo> topResults,
    NeighborInfo neighborInfo,
    int maxNumResults) {
  if (topResults.size() < maxNumResults) {
    topResults.add(neighborInfo);
  } else if (neighborInfo.getScore() > topResults.peek().getScore()) {
    topResults.poll();
    topResults.add(neighborInfo);
  }
}
 
Example 13
/**
 * Helper method to add a value to a {@link PriorityQueue}.
 *
 * @param value value to be added.
 * @param queue priority queue.
 * @param maxNumValues maximum number of values in the priority queue.
 * @param <T> type for the value.
 */
public static <T> void addToPriorityQueue(T value, PriorityQueue<T> queue, int maxNumValues) {
  if (queue.size() < maxNumValues) {
    queue.add(value);
  } else if (queue.comparator().compare(queue.peek(), value) < 0) {
    queue.poll();
    queue.offer(value);
  }
}
 
Example 14
/**
 *
 * @param vector
 * @param n
 * @return
 * @throws IOException
 */
public List<SpaceResult> findFileSimilar(float[] vector, int n) throws IOException {
    PriorityQueue<SpaceResult> queue = new PriorityQueue<>();
    indexInput.seek(0);
    String header = indexInput.readString(); //skip header
    if ((header.equalsIgnoreCase("-dimensions"))) {
        ObjectVector.vecLength = indexInput.readInt();
    } else if (header.contains("-dimension")) {
        int index = header.indexOf("-dimension");
        ObjectVector.vecLength = Integer.parseInt(header.substring(index + 10).trim());
    }
    while (indexInput.getFilePointer() < indexInput.length()) {
        String key = indexInput.readString();
        float[] v = new float[ObjectVector.vecLength];
        for (int k = 0; k < v.length; k++) {
            v[k] = Float.intBitsToFloat(indexInput.readInt());
        }
        float score = VectorUtils.scalarProduct(vector, v);
        if (queue.size() < n) {
            queue.offer(new SpaceResult(key, score));
        } else {
            queue.poll();
            queue.offer(new SpaceResult(key, score));
        }

    }
    queue.poll();
    List<SpaceResult> list = new ArrayList<>(queue);
    Collections.sort(list);
    return list;
}
 
Example 15
Source Project: codekata   File: Solution.java    License: MIT License 5 votes vote down vote up
public int lastStoneWeight(int[] stones) {
    PriorityQueue<Integer> heap = new PriorityQueue<>(stones.length, Collections.reverseOrder());
    for (int stone : stones) {
        heap.add(stone);
    }

    while (heap.size() > 1) {
        int a = heap.poll(), b = heap.poll();
        if (a != b) {
            heap.add(a - b);
        }
    }
    return heap.size() == 0 ? 0 : heap.poll();
}
 
Example 16
Source Project: GraphJet   File: GeneratorHelper.java    License: Apache License 2.0 5 votes vote down vote up
public static void addResultToPriorityQueue(
  PriorityQueue<NodeInfo> topResults,
  NodeInfo nodeInfo,
  int maxNumResults) {
  if (topResults.size() < maxNumResults) {
    topResults.add(nodeInfo);
  } else if (nodeInfo.getWeight() > topResults.peek().getWeight()) {
    topResults.poll();
    topResults.add(nodeInfo);
  }
}
 
Example 17
Source Project: NLIDB   File: QueryTree.java    License: Apache License 2.0 5 votes vote down vote up
public QueryTree (ParseTree T){
	results = new ArrayList<ParseTree>();
	PriorityQueue<ParseTree> Q = new PriorityQueue<ParseTree>();
	Q.add(T);
	HashMap<Integer, ParseTree> H = new HashMap<Integer, ParseTree>();
	H.put(hashing(T), T);
	T.setEdit(0);
	
	while (Q.size() > 0){
		ParseTree oriTree = Q.poll();
		List<ParseTree> treeList = adjuster(oriTree);
		double treeScore = evaluate(oriTree);
		
		for (int i = 0; i < treeList.size(); i++){
			ParseTree currentTree = treeList.get(i);
			int hashValue = hashing(currentTree);
			if (oriTree.getEdit()<10 && !H.containsKey(hashValue)){
				H.put(hashValue, currentTree);
				currentTree.setEdit(oriTree.getEdit()+1);
				if (evaluate(currentTree) >= treeScore){
					Q.add(currentTree);
					results.add(currentTree);
				}
			}
		}
	}
}
 
Example 18
Source Project: lucene-solr   File: DirectSpellChecker.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * Provide spelling corrections based on several parameters.
 *
 * @param term The term to suggest spelling corrections for
 * @param numSug The maximum number of spelling corrections
 * @param ir The index reader to fetch the candidate spelling corrections from
 * @param docfreq The minimum document frequency a potential suggestion need to have in order to be included
 * @param editDistance The maximum edit distance candidates are allowed to have
 * @param accuracy The minimum accuracy a suggested spelling correction needs to have in order to be included
 * @param spare a chars scratch
 * @return a collection of spelling corrections sorted by <code>ScoreTerm</code>'s natural order.
 * @throws IOException If I/O related errors occur
 */
protected Collection<ScoreTerm> suggestSimilar(Term term, int numSug, IndexReader ir, int docfreq, int editDistance,
                                               float accuracy, final CharsRefBuilder spare) throws IOException {

  Terms terms = MultiTerms.getTerms(ir, term.field());
  if (terms == null) {
    return Collections.emptyList();
  }
  FuzzyTermsEnum e = new FuzzyTermsEnum(terms, term, editDistance, Math.max(minPrefix, editDistance - 1), true);
  final PriorityQueue<ScoreTerm> stQueue = new PriorityQueue<>();
  
  BytesRef queryTerm = new BytesRef(term.text());
  BytesRef candidateTerm;
  ScoreTerm st = new ScoreTerm();
  while ((candidateTerm = e.next()) != null) {
    // For FuzzyQuery, boost is the score:
    float score = e.getBoost();
    // ignore uncompetitive hits
    if (stQueue.size() >= numSug && score <= stQueue.peek().boost) {
      continue;
    }
    
    // ignore exact match of the same term
    if (queryTerm.bytesEquals(candidateTerm)) {
      continue;
    }
    
    int df = e.docFreq();
    
    // check docFreq if required
    if (df <= docfreq) {
      continue;
    }
    
    final String termAsString;
    if (distance == INTERNAL_LEVENSHTEIN) {
      // delay creating strings until the end
      termAsString = null;
    } else {
      spare.copyUTF8Bytes(candidateTerm);
      termAsString = spare.toString();
      score = distance.getDistance(term.text(), termAsString);
    }
    
    if (score < accuracy) {
      continue;
    }
    
    // add new entry in PQ
    st.term = BytesRef.deepCopyOf(candidateTerm);
    st.boost = score;
    st.docfreq = df;
    st.termAsString = termAsString;
    st.score = score;
    stQueue.offer(st);
    // possibly drop entries from queue
    st = (stQueue.size() > numSug) ? stQueue.poll() : new ScoreTerm();
    e.setMaxNonCompetitiveBoost((stQueue.size() >= numSug) ? stQueue.peek().boost : Float.NEGATIVE_INFINITY);
  }
    
  return stQueue;
}
 
Example 19
Source Project: lucene-solr   File: PossibilityIterator.java    License: Apache License 2.0 4 votes vote down vote up
/**
 * <p>
 * We assume here that the passed-in inner LinkedHashMaps are already sorted
 * in order of "Best Possible Correction".
 * </p>
 */
public PossibilityIterator(
    Map<Token,LinkedHashMap<String,Integer>> suggestions,
    int maximumRequiredSuggestions, int maxEvaluations, boolean overlap) {
  this.suggestionsMayOverlap = overlap;
  for (Map.Entry<Token,LinkedHashMap<String,Integer>> entry : suggestions
      .entrySet()) {
    Token token = entry.getKey();
    if (entry.getValue().size() == 0) {
      continue;
    }
    List<SpellCheckCorrection> possibleCorrections = new ArrayList<>();
    for (Map.Entry<String,Integer> entry1 : entry.getValue().entrySet()) {
      SpellCheckCorrection correction = new SpellCheckCorrection();
      correction.setOriginal(token);
      correction.setCorrection(entry1.getKey());
      correction.setNumberOfOccurences(entry1.getValue());
      possibleCorrections.add(correction);
    }
    possibilityList.add(possibleCorrections);
  }
  
  int wrapSize = possibilityList.size();
  if (wrapSize == 0) {
    done = true;
  } else {
    correctionIndex = new int[wrapSize];
    for (int i = 0; i < wrapSize; i++) {
      int suggestSize = possibilityList.get(i).size();
      if (suggestSize == 0) {
        done = true;
        break;
      }
      correctionIndex[i] = 0;
    }
  }
  PriorityQueue<RankedSpellPossibility> rankedPossibilities = new PriorityQueue<>(
      11, new RankComparator());
  Set<RankedSpellPossibility> removeDuplicates = null;
  if (suggestionsMayOverlap) {
    removeDuplicates = new HashSet<>();
  }
  long numEvaluations = 0;
  while (numEvaluations < maxEvaluations && internalHasNext()) {
    RankedSpellPossibility rsp = internalNext();
    numEvaluations++;
    if (rankedPossibilities.size() >= maximumRequiredSuggestions
        && rsp.rank >= rankedPossibilities.peek().rank) {
      continue;
    }
    if (!isSuggestionForReal(rsp)) {
      continue;
    }
    if (removeDuplicates == null) {
      rankedPossibilities.offer(rsp);
    } else {
      // Needs to be in token-offset order so that the match-and-replace
      // option for collations can work.
      Collections.sort(rsp.corrections, new StartOffsetComparator());
      if (removeDuplicates.add(rsp)) {
        rankedPossibilities.offer(rsp);
      }
    }
    if (rankedPossibilities.size() > maximumRequiredSuggestions) {
      RankedSpellPossibility removed = rankedPossibilities.poll();
      if (removeDuplicates != null) {
        removeDuplicates.remove(removed);
      }
    }
  }
  
  RankedSpellPossibility[] rpArr = new RankedSpellPossibility[rankedPossibilities
      .size()];
  for (int i = rankedPossibilities.size() - 1; i >= 0; i--) {
    rpArr[i] = rankedPossibilities.remove();
  }
  rankedPossibilityIterator = Arrays.asList(rpArr).iterator();
}
 
Example 20
Source Project: brouter   File: RouteServer.java    License: MIT License 4 votes vote down vote up
public static void main(String[] args) throws Exception
{
      System.out.println("BRouter 1.6.1 / 01032020");
      if ( args.length != 5 && args.length != 6)
      {
        System.out.println("serve BRouter protocol");
        System.out.println("usage: java RouteServer <segmentdir> <profiledir> <customprofiledir> <port> <maxthreads> [bindaddress]");
        return;
      }

      ServiceContext serviceContext = new ServiceContext();
      serviceContext.segmentDir = args[0];
      serviceContext.profileDir = args[1];
      System.setProperty( "profileBaseDir", serviceContext.profileDir );
      String dirs = args[2];
      StringTokenizer tk = new StringTokenizer( dirs, "," );
      serviceContext.customProfileDir = tk.nextToken();
      serviceContext.sharedProfileDir = tk.hasMoreTokens() ? tk.nextToken() : serviceContext.customProfileDir;

      int maxthreads = Integer.parseInt( args[4] );
      
      ProfileCache.setSize( 2*maxthreads );

      PriorityQueue<RouteServer> threadQueue = new PriorityQueue<RouteServer>();

      ServerSocket serverSocket = args.length > 5 ? new ServerSocket(Integer.parseInt(args[3]),100,InetAddress.getByName(args[5])) : new ServerSocket(Integer.parseInt(args[3]));

      // stacksample for performance profiling
      // ( caution: start stacksampler only after successfully creating the server socket
      //   because that thread prevents the process from terminating, so the start-attempt
      //   by the watchdog cron would create zombies )
      File stackLog = new File( "stacks.txt" );
      if ( stackLog.exists() )
      {
        StackSampler stackSampler = new StackSampler( stackLog, 1000 );
        stackSampler.start();
        System.out.println( "*** sampling stacks into stacks.txt *** ");
      }

      for (;;)
      {
        Socket clientSocket = serverSocket.accept();
        RouteServer server = new RouteServer();
        server.serviceContext = serviceContext;
        server.clientSocket = clientSocket;
        server.starttime = System.currentTimeMillis();

        // kill an old thread if thread limit reached

        cleanupThreadQueue( threadQueue );

        if ( debug ) System.out.println( "threadQueue.size()=" + threadQueue.size() );
        if ( threadQueue.size() >= maxthreads )
        {
           synchronized( threadPoolSync )
           {
             // wait up to 2000ms (maybe notified earlier)
             // to prevent killing short-running threads
             long maxage = server.starttime - threadQueue.peek().starttime;
             long maxWaitTime = 2000L-maxage;
             if ( debug ) System.out.println( "maxage=" + maxage + " maxWaitTime=" + maxWaitTime );
             if ( debug )
             {
               for ( RouteServer t : threadQueue )
               {
                 System.out.println( "age=" + (server.starttime - t.starttime) );
               }
             }
             if ( maxWaitTime > 0 )
             {
               threadPoolSync.wait( maxWaitTime );
             }
           }
           cleanupThreadQueue( threadQueue );
           if ( threadQueue.size() >= maxthreads )
           {
             if ( debug ) System.out.println( "stopping oldest thread..." );
             // no way... stop the oldest thread
             threadQueue.poll().stopRouter();
           }
        }

        threadQueue.add( server );

        server.start();
        if ( debug ) System.out.println( "thread started..." );
      }
}