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(); }
final int nitems = itemUniverse.size();
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); }
@Test public void testSubSet() { long[] data = {0, 42, 5, 2, 6, 1, 7}; LongSortedSet set = new LongSortedArraySet(data); assertEquals(data.length, set.size()); testSetSimple(set.subSet(2, 7)); }
@Test public void testTailSet() { long[] data = {0, 5, 2, 6, 1}; LongSortedSet set = new LongSortedArraySet(data); assertEquals(data.length, set.size()); testSetSimple(set.tailSet(2)); }
@Test public void testAdaptive() { LongIterator iter = new AdaptiveSparseItemIterator(context, LongUtils.packedSet(12, 42)); LongList items = LongIterators.pour(iter); // since 12 has too many items, it will use all items instead of 42's items assertThat(items, hasSize(context.getItems().size())); assertThat(LongUtils.packedSet(items), equalTo(context.getItems())); } }
@Test public void testHeadSet() { long[] data = {7, 5, 2, 6, 42}; LongSortedSet set = new LongSortedArraySet(data); assertEquals(data.length, set.size()); testSetSimple(set.headSet(7)); }
int n = commonKeys.size(); if (n == 0) { return 0;
@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); }
@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))); }
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(); }
/** * 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]); }
final int nitems = itemUniverse.size();
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); }
else if (o instanceof LongSortedSet) { // For sorted sets, we require the same order LongSortedSet s = (LongSortedSet) o; if (s.size() != length()) return false; long n = length(); LongIterator i = iterator(), j = s.iterator();