/** * Get the set of known items. * @return The set of known items. */ public LongSortedSet getKnownItems() { return items.keySet(); }
@Override public LongSortedArraySet keySet() { return keys.keySet(); }
@Override public LongSortedSet getItemUniverse() { return itemDomain.keySet(); }
public LongSet getItems() { return itemIndex.keySet(); }
/** * Get the set of items. * * @return The set of all items to build a model over. */ @Nonnull public LongSortedSet getItems() { return items.keySet(); }
/** * Pack longs into a sorted set. * @param longs An array of longs. This array is copied, not wrapped. * @return An efficient sorted set containing the numbers in {@code longs}. */ public static LongSortedArraySet packedSet(long... longs) { return SortedKeyIndex.create(longs).keySet(); }
/** * Pack longs into a sorted set. * @param longs A collection of longs. * @return An efficient sorted set containing the numbers in {@code longs}. */ public static LongSortedArraySet packedSet(Collection<Long> longs) { if (longs instanceof LongSortedArraySet) { return (LongSortedArraySet) longs; } else { return SortedKeyIndex.fromCollection(longs).keySet(); } }
/** * Get a Fastutil {@link LongSet} from a {@link java.util.Collection} of longs. * * @param longs The set of longs. * @return {@code longs} as a fastutil {@link LongSet}. If {@code longs} is already * a LongSet, it is cast. */ public static LongSet asLongSet(@Nullable final Collection<Long> longs) { if (longs == null) { return null; } else if (longs instanceof Set) { return asLongSet((Set<Long>) longs); } else { return SortedKeyIndex.fromCollection(longs).keySet(); } }
/** * 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(); }
@Test public void testEmptyCollection() { SortedKeyIndex keys = SortedKeyIndex.fromCollection(LongLists.EMPTY_LIST); assertThat(keys.size(), equalTo(0)); assertThat(keys.size(), equalTo(0)); assertThat(keys.keySet(), hasSize(0)); assertThat(keys.getKeyList(), hasSize(0)); }
@Test public void testEmptyArray() { long[] rawKeys = {}; SortedKeyIndex keys = SortedKeyIndex.wrap(rawKeys, 0); assertThat(keys.size(), equalTo(0)); assertThat(keys.size(), equalTo(0)); assertThat(keys.keySet(), hasSize(0)); assertThat(keys.getKeyList(), hasSize(0)); assertThat(keys.tryGetIndex(42), lessThan(0)); }
/** * Construct a new interaction statistics object. * * @param type The counted entity type. * @param counts A map of item interaction counts. */ public InteractionStatistics(EntityType type, Long2IntMap counts) { entityType = type; items = SortedKeyIndex.fromCollection(counts.keySet()); int n = items.size(); interactionCounts = new int[n]; for (int i = 0; i < n; i++) { interactionCounts[i] = counts.get(items.getKey(i)); } long[] iarray = items.keySet().toLongArray(); LongArrays.quickSort(iarray, (l1, l2) -> Doubles.compare(counts.get(l2), counts.get(l1))); itemList = LongArrayList.wrap(iarray); }
@Theory public void testABunch(KeyData data) { long[] rawKeys = data.getKeys(10); List<Long> keyList = new LongArrayList(rawKeys); SortedKeyIndex keys = SortedKeyIndex.wrap(rawKeys, rawKeys.length); assertThat(keys.size(), equalTo(10)); assertThat(keys.size(), equalTo(10)); assertThat(keys.getKeyList(), contains(keyList.toArray())); assertThat(keys.keySet(), contains(keyList.toArray())); assertThat(keys.tryGetIndex(data.getLow()), lessThan(0)); for (int i = 0; i < 10; i++) { assumeThat(keys.tryGetIndex(rawKeys[i]), equalTo(i)); assertThat(keys.tryGetIndex(data.getAfter(i)), lessThan(0)); } } }
return SortedKeyIndex.wrap(data, i).keySet();
@Theory public void testSingleton(KeyData data) { assumeThat(data, notNullValue()); long key = data.getKey(); // key to use long low = data.getLow(); // unused low key long high = data.getAfter(1); // unused high key long[] rawKeys = {key}; SortedKeyIndex keys = SortedKeyIndex.wrap(rawKeys, 1); assertThat(keys.size(), equalTo(1)); assertThat(keys.size(), equalTo(1)); assertThat(keys.keySet(), hasSize(1)); assertThat(keys.tryGetIndex(key), equalTo(0)); assertThat(keys.tryGetIndex(low), lessThan(0)); assertThat(keys.tryGetIndex(high), lessThan(0)); assertThat(keys.getKeyList(), contains(key)); }
@Theory public void testMultiple(KeyData data) { long[] rawKeys = data.getKeys(3); long k1 = rawKeys[0]; long k2 = rawKeys[1]; long k3 = rawKeys[2]; SortedKeyIndex keys = SortedKeyIndex.wrap(rawKeys, 3); assertThat(keys.size(), equalTo(3)); assertThat(keys.size(), equalTo(3)); assertThat(keys.getKeyList(), contains(k1, k2, k3)); assertThat(keys.keySet(), contains(k1, k2, k3)); assertThat(keys.tryGetIndex(k1), equalTo(0)); assertThat(keys.tryGetIndex(k2), equalTo(1)); assertThat(keys.tryGetIndex(k3), equalTo(2)); assertThat(keys.tryGetIndex(data.getLow()), lessThan(0)); assertThat(keys.tryGetIndex(data.getAfter(0)), lessThan(0)); assertThat(keys.tryGetIndex(data.getAfter(1)), lessThan(0)); assertThat(keys.tryGetIndex(data.getAfter(2)), lessThan(0)); }