public void mergeWith(SetDigest other) { hll.mergeWith(other.hll); LongBidirectionalIterator iterator = other.minhash.keySet().iterator(); while (iterator.hasNext()) { long key = iterator.nextLong(); int count = minhash.get(key) + other.minhash.get(key); minhash.put(key, Shorts.saturatedCast(count)); } while (minhash.size() > maxHashes) { minhash.remove(minhash.lastLongKey()); } }
private Long2DoubleSortedArrayMap slowSubMap(LongSet toKeep) { LongSortedSet kept = LongUtils.setIntersect(keySet(), toKeep); double[] nvs = new double[kept.size()]; int i = keys.getLowerBound(); int j = 0; LongIterator iter = kept.iterator(); while (iter.hasNext()) { long key = iter.nextLong(); while (keys.getKey(i) < key) { i++; } nvs[j] = values[i]; j++; i++; } return wrap(SortedKeyIndex.fromCollection(kept), nvs); }
/** * Run a battery of tests on a standard set. Used to test a variety of * construction scenarios with less code duplication. * * @param set The set {2, 5, 6}. */ private void testSetSimple(LongSortedSet set) { assertFalse(set.isEmpty()); assertEquals(3, set.size()); assertEquals(2, set.firstLong()); assertEquals(6, set.lastLong()); assertEquals(Long.valueOf(2), set.first()); assertEquals(Long.valueOf(6), set.last()); assertTrue(set.contains(2)); assertTrue(set.contains(5)); assertTrue(set.contains(6)); assertFalse(set.contains(0)); assertFalse(set.contains(42)); assertFalse(set.iterator().hasPrevious()); long[] items = LongIterators.unwrap(set.iterator()); assertEquals(2, items[0]); assertEquals(5, items[1]); assertEquals(6, items[2]); }
public AdaptiveSparseItemIterator(ItemItemBuildContext context, LongSet users, long lowerBound) { this.context = context; this.users = users; this.lowerBound = lowerBound; if (lowerBound == Long.MIN_VALUE) { universeSize = context.getItems().size(); } else { // since universe size is only used for sparsity estimation, it is // fine to have an off-by-1 discrepancy between this & iterator behavior universeSize = context.getItems().tailSet(lowerBound).size(); } seen = new LongOpenHashSet(context.getItems().size()); userIter = users.iterator(); }
@Override public SimilarityMatrixModel get() { logger.info("building item-item model for {} items", buildContext.getItems().size()); logger.debug("using similarity function {}", itemSimilarity); logger.debug("similarity function is {}", final int nitems = allItems.size(); Stream<Long> idStream; if (ClassQueries.isThreadSafe(itemSimilarity)) { idStream = allItems.parallelStream(); } else { logger.warn("similarity {} is not thread-safe, disabling parallel build", itemSimilarity); idStream = allItems.stream();
@Test public void testSubsetIterator() { LongSortedSet set = LongUtils.packedSet(1L, 3L, 5L, 10L); LongSortedSet subset = set.subSet(3L, 6L); assertThat(subset, hasSize(2)); assertThat(subset, contains(3L, 5L)); LongBidirectionalIterator iter = subset.iterator(); assertThat(iter.hasPrevious(), equalTo(false)); try { iter.previousLong(); fail("previousLong should fail"); } catch (NoSuchElementException e) { /* expected */ } }
@Test public void testEmptySetSubset() { LongSortedArraySet set = emptySet(); LongSortedSet sset = set.headSet(50); assertTrue(sset.isEmpty()); assertEquals(0, sset.size()); assertFalse(set.iterator().hasNext()); assertFalse(set.iterator().hasPrevious()); assertFalse(set.contains(42)); assertFalse(set.contains(Long.valueOf(42))); }
/** * {@inheritDoc} * * @deprecated Please use the corresponding type-specific method instead. */ @Deprecated @Override default LongSortedSet tailSet(final Long from) { return tailSet(from.longValue()); } /**
@Nonnull @Override public ResultMap predictWithDetails(long user, @Nonnull Collection<Long> items) { List<Rating> ratings = dao.query(Rating.class) .withAttribute(CommonAttributes.USER_ID, user) .get(); LongSortedSet wantedItems = LongUtils.packedSet(items); List<Result> results = new ArrayList<>(); for (Rating r: ratings) { long item = r.getItemId(); if (wantedItems.contains(r.getItemId())) { results.add(Results.create(item, r.getValue())); } } return Results.newResultMap(results); } }
/** * {@inheritDoc} * * @deprecated Please use the corresponding type-specific method instead. */ @Deprecated @Override default LongSortedSet subSet(final Long from, final Long to) { return subSet(from.longValue(), to.longValue()); } /**
@Inject public PopularityRankItemScorer(final InteractionStatistics stats) { statistics = stats; long[] items = stats.getKnownItems().toLongArray(); LongArrays.quickSort(items, (l1, l2) -> Integer.compare(stats.getInteractionCount(l2), stats.getInteractionCount(l1))); Long2IntMap ranks = LongUtils.itemRanks(LongArrayList.wrap(items)); SortedKeyIndex keys = SortedKeyIndex.fromCollection(ranks.keySet()); int n = keys.size(); double[] values = new double[n]; for (int i = 0; i < n; i++) { values[i] = 1.0 - ranks.get(keys.getKey(i)) / ((double) n); } rankScores = Long2DoubleSortedArrayMap.wrap(keys, values); }
@Nonnull @Override public MetricResult measureUser(TestUser user, ResultMap predictions, Context context) { int n = user.getTestRatings().size(); int good = predictions.size(); assert LongUtils.setDifference(LongUtils.asLongSet(predictions.keySet()), user.getTestRatings().keySet()) .isEmpty(); context.addUser(n, good); return new Coverage(n, good); }
final int nitems = itemUniverse.size();
@Override public SimilarityMatrixModel get() { logger.info("building item-item model for {} items", buildContext.getItems().size()); logger.debug("using similarity function {}", itemSimilarity); logger.debug("similarity function is {}", final int nitems = allItems.size(); Stream<Long> idStream; if (ClassQueries.isThreadSafe(itemSimilarity)) { idStream = allItems.parallelStream(); } else { logger.warn("similarity {} is not thread-safe, disabling parallel build", itemSimilarity); idStream = allItems.stream();
@Before public void createContext() { LongSortedSet universe = LongUtils.packedSet(1, 2, 5, 7, 9, 13, 14, 17, 68, 32, 97); Long2ObjectMap<LongSortedSet> userItems = new Long2ObjectOpenHashMap<>(); userItems.put(42, LongUtils.packedSet(2, 5, 9)); userItems.put(39, LongUtils.packedSet(2, 7, 9, 13)); userItems.put(12, universe.subSet(2, 97)); context = new ItemItemBuildContext(SortedKeyIndex.fromCollection(universe), new Long2DoubleSortedMap[universe.size()], userItems); }
/** * {@inheritDoc} * * @deprecated Please use the corresponding type-specific method instead. */ @Deprecated @Override public LongSortedSet tailSet(final Long from) { return new UnmodifiableSortedSet(sortedSet.tailSet(from)); } }