Refine search
/** * Compute the size of the intersection of two sets. * @param a The first set. * @param b The second set. * @return The size of the intersection of the two sets. */ public static int intersectSize(LongSet a, LongSet b) { if (a instanceof LongSortedSet && b instanceof LongSortedSet) { return intersectSize((LongSortedSet) a, (LongSortedSet) b); } else { int n = 0; LongIterator iter = a.iterator(); while (iter.hasNext()) { long x = iter.nextLong(); if (b.contains(x)) { n += 1; } } return n; } }
@Override public String get() { String name = fileName; logger.info("writing {}", name); File file = new File(workingDir, name); try (PrintWriter writer = new PrintWriter(file, CHARSET_UTF_8)) { LongIterator iter = identifiers.iterator(); while (iter.hasNext()) { writer.println(iter.nextLong()); } } catch (IOException e) { throw new ExternalProcessException("Error creating ratings file", e); } return name; } }
public void markDeletes(LongSet delDocs, LongSet deletedUIDs) { LongIterator iter = delDocs.iterator(); IntRBTreeSet delDocIdSet = _delDocIdSet; while (iter.hasNext()) { long uid = iter.nextLong(); if (ZoieSegmentReader.DELETED_UID != uid) { int docid = _docIDMapper.getDocID(uid); if (docid != DocIDMapper.NOT_FOUND) { delDocIdSet.add(docid); deletedUIDs.add(uid); } } } }
if (universeSize - seen.size() <= universeSize / 4 && usersSeen <= users.size() / 2) { if (logger.isTraceEnabled()) { logger.trace("dropping sparsity, using full universe (saw {} of {} items, {} of {} users)", seen.size(), universeSize, usersSeen, users.size()); } else if (userIter.hasNext()) { long user = userIter.nextLong(); usersSeen += 1; items = context.getUserItems(user); } else if (currentItems.hasNext()) { nextItem = currentItems.nextLong(); if (!seen.contains(nextItem)) {
/** * Get the IDs of the candidate neighbors for a user. * @param user The user. * @param userItems The user's rated items. * @param targetItems The set of target items. * @return The set of IDs of candidate neighbors. */ private LongSet findCandidateNeighbors(long user, LongSet userItems, LongCollection targetItems) { LongSet users = new LongOpenHashSet(100); LongIterator items; if (userItems.size() < targetItems.size()) { items = userItems.iterator(); } else { items = targetItems.iterator(); } while (items.hasNext()) { LongSet iusers = dao.query(CommonTypes.RATING) .withAttribute(CommonAttributes.ITEM_ID, items.nextLong()) .valueSet(CommonAttributes.USER_ID); if (iusers != null) { users.addAll(iusers); } } users.remove(user); return users; }
@Override public RandomAccessFilter buildRandomAccessAndFilter(String[] vals, Properties prop) throws IOException { LongSet longSet = new LongOpenHashSet(); for (String val : vals) { try { longSet.add(Long.parseLong(val)); } catch (Exception e) { throw new IOException(e.getMessage()); } } if (longSet.size() != 1) { return EmptyFilter.getInstance(); } else { return buildRandomAccessFilter(longSet.iterator().nextLong()); } }
static ResultList merge(int n, ResultList left, ResultList right, double weight) { Long2IntMap leftRanks = LongUtils.itemRanks(LongUtils.asLongList(left.idList())); Long2IntMap rightRanks = LongUtils.itemRanks(LongUtils.asLongList(right.idList())); int nl = left.size(); int nr = right.size(); LongSet allItems = new LongOpenHashSet(); allItems.addAll(leftRanks.keySet()); allItems.addAll(rightRanks.keySet()); ResultAccumulator accum = ResultAccumulator.create(n); for (LongIterator iter = allItems.iterator(); iter.hasNext();) { long item = iter.nextLong(); int rl = leftRanks.get(item); int rr = rightRanks.get(item); double s1 = rankToScore(rl, nl); double s2 = rankToScore(rr, nr); double score = weight * s1 + (1.0-weight) * s2; accum.add(new RankBlendResult(item, score, rl >= 0 ? left.get(rl) : null, rl, rr >= 0 ? right.get(rr) : null, rl)); } return accum.finish(); }
/** * {@inheritDoc} * * <p> * This implementation iterates over the elements in the collection, looking for * the specified element and tries to remove it. */ @Override public boolean rem(final long k) { final LongIterator iterator = iterator(); while (iterator.hasNext()) if (k == iterator.nextLong()) { iterator.remove(); return true; } return false; } /**
private boolean doTruncateInvalidTxBefore(long time) throws InvalidTruncateTimeException { LOG.info("Removing tx ids before {} from invalid list", time); long truncateWp = time * TxConstants.MAX_TX_PER_MS; // Check if there any in-progress transactions started earlier than truncate time if (inProgress.lowerKey(truncateWp) != null) { throw new InvalidTruncateTimeException("Transactions started earlier than " + time + " are in-progress"); } // Find all invalid transactions earlier than truncateWp LongSet toTruncate = new LongArraySet(); LongIterator it = invalidTxList.toRawList().iterator(); while (it.hasNext()) { long wp = it.nextLong(); if (wp < truncateWp) { toTruncate.add(wp); } } LOG.info("Removing tx ids {} from invalid list", toTruncate); return invalidTxList.removeAll(toTruncate); }
private void clear() { this.shader_to_lights.clear(); this.light_shaders.clear(); this.lights.clear(); this.lights_unclipped.clear(); final LongIterator iter = this.clip_groups.keySet().iterator(); while (iter.hasNext()) { final ClipGroup cg = this.clip_groups.get(iter.nextLong()); cg.shader_to_lights.clear(); cg.deleted = true; } this.clip_groups.clear(); }
@Override public LocalDateTime next() { return PackedLocalDateTime.asLocalDateTime(longIterator.nextLong()); } };
@Test public void testDotVectors() { for (Map<Long,Double> map: someMaps(longs(), doubles(-1000, 1000))) { Long2DoubleMap m = new Long2DoubleOpenHashMap(map); assertThat(Vectors.dotProduct(m, m), equalTo(Vectors.sumOfSquares(m))); if (!m.isEmpty()) { long k1 = m.keySet().iterator().nextLong(); double v1 = m.get(k1); Long2DoubleMap m2 = new Long2DoubleOpenHashMap(m); m2.remove(k1); long k2 = k1; // find a key we haven't seen yet while (m2.containsKey(k2) || k2 == k1) { k2++; } m2.put(k2, v1); // and test that it is missing from the dot product assertThat(Vectors.dotProduct(m, m2), closeTo(Vectors.sumOfSquares(m) - v1 * v1, 1.0e-6)); } } }
@Override public boolean hasNext() { return longIterator.hasNext(); }
@Override public LocalDateTime next() { return PackedLocalDateTime.asLocalDateTime(longIterator.next()); } };
@Override public void remove() { neighborsIt.remove(); } };
/** * Compute the set difference of two sets. * * @param items The initial set * @param exclude The items to remove * @return The elements of <var>items</var> that are not in <var>exclude</var>. */ public static LongSortedSet setDifference(LongSet items, LongSet exclude) { long[] data = new long[items.size()]; final LongIterator iter = items.iterator(); int i = 0; while (iter.hasNext()) { final long x = iter.nextLong(); if (!exclude.contains(x)) { data[i++] = x; } } if (!(items instanceof LongSortedSet)) { Arrays.sort(data, 0, i); } // trim the array if (data.length * 2 > i * 3) { data = Arrays.copyOf(data, i); } return SortedKeyIndex.wrap(data, i).keySet(); }
/** * Constructs and returns a {@link SlopeOneModel}. */ @Override public SlopeOneModel get() { LongSet items = buildContext.getItems(); LongIterator outer = items.iterator(); while (outer.hasNext()) { final long item1 = outer.nextLong(); final Long2DoubleSortedMap vec1 = buildContext.itemVector(item1); LongIterator inner = items.iterator(); while (inner.hasNext()) { final long item2 = inner.nextLong(); if (item1 != item2) { Long2DoubleSortedMap vec2 = buildContext.itemVector(item2); accumulator.putItemPair(item1, vec1, item2, vec2); } } } return new SlopeOneModel(accumulator.buildMatrix()); } }