How to use

singleton

method

in

it.unimi.dsi.fastutil.longs.LongSets

/**
 * {@inheritDoc}
 *
 * This implementation delegates to {@link #recommendRelatedItems(Set, int)}.
 */
@Override
public List<Long> recommendRelatedItems(long reference, int n) {
  return recommendRelatedItems(LongSets.singleton(reference), n);
}

  /**
   * {@inheritDoc}
   *
   * This implementation delegates to {@link #scoreRelatedItemsWithDetails(Collection, Collection)}.
   */
  @Override
  public Result scoreRelatedItem(@Nonnull Collection<Long> basket, long item) {
    return scoreRelatedItemsWithDetails(basket, LongSets.singleton(item)).get(item);
  }
}

/**
 * {@inheritDoc}
 *
 * This implementation delegates to {@link #scoreWithDetails(long, Collection)}.
 */
@Override
public Result score(long user, long item) {
  ResultMap results = scoreWithDetails(user, LongSets.singleton(item));
  return results.get(item);
}

/**
 * {@inheritDoc}
 *
 * This implementation delegates to {@link #predictWithDetails(long, Collection)}.
 */
@Override
public Result predict(long user, long item) {
  ResultMap results = predictWithDetails(user, LongSets.singleton(item));
  return results.get(item);
}

/**
 * Tests {@code recommendRelatedItems()(long, int)}.
 */
@Test
public void testGlobalItemItemRecommender2() {
  List<Long> recs = gRecommender.recommendRelatedItems(LongSets.singleton(1), 2);
  assertThat(recs, hasSize(2));
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(2), 1);
  assertThat(recs, empty());
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(5), 3);
  assertThat(recs, hasSize(3));
}

/**
 * Tests {@code globalRecommend(long)}.
 */
// FIXME Give the test methods for global item-item meaningful names
@Test
public void testGlobalItemItemRecommender1() {
  List<Long> recs = gRecommender.recommendRelatedItems(LongSets.singleton(1));
  assertThat(recs.size(), notNullValue());
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(2));
  assertThat(recs, empty());
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(5));
  assertThat(recs.size(), notNullValue());
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(1));
  assertThat(recs.size(), notNullValue());
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(10));
  assertThat(recs.size(), notNullValue());
}

/**
 * Tests {@code recommendRelatedItems()(long, int, Set, Set)}.
 */
@Test
public void testGlobalItemItemRecommender4() {
  HashSet<Long> candidates = new HashSet<>();
  HashSet<Long> excludes = new HashSet<>();
  List<Long> recs = gRecommender.recommendRelatedItems(LongSets.singleton(1), 1, candidates, excludes);
  assertThat(recs, hasSize(0));
  candidates.add(7L);
  candidates.add(5L);
  excludes.add(5L);
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(1), 2, candidates, excludes);
  assertThat(recs, hasSize(1));
  assertThat(recs, contains(7L));
  recs = gRecommender.recommendRelatedItems(LongSets.singleton(1), -1, candidates, excludes);
  assertThat(recs, hasSize(1));
  assertThat(recs, contains(7L));
}

@Test
public void testRandomSubsetPickExclude() {
  LongSortedArraySet singleton = LongUtils.packedSet(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  Random rng = new Random();
  for (int i = 0; i < 50; i++) {
    LongSortedSet sample = singleton.randomSubset(rng, 5, LongSets.singleton(7L));
    assertThat(sample, hasSize(5));
    assertThat(sample, everyItem(allOf(greaterThan(0L), lessThan(11L))));
    assertThat(sample, not(hasItem(7L)));
  }
}

@Override
public LongCollection values() {
  if (values == null)
    values = LongSets.singleton(value);
  return values;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongCollection values() {
  if (values == null)
    values = LongSets.singleton(value);
  return values;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongSet keySet() {
  if (keys == null)
    keys = LongSets.singleton(key);
  return keys;
}
@Override

@Override
public LongCollection values() {
  if (values == null)
    values = LongSets.singleton(value);
  return values;
}
@Override

@Test
public void testExcludeScore() {
  StaticDataSource source = new StaticDataSource();
  source.addSource(ImmutableList.of(Entities.create(CommonTypes.ITEM, 3)));
  DataAccessObject dao = source.get();
  ItemScorer scorer = PrecomputedItemScorer.newBuilder()
                       .addScore(42, 3, 3.5)
                       .build();
  ItemRecommender rec = new TopNItemRecommender(dao, scorer);
  List<Long> recs = rec.recommend(42, -1, null, LongSets.singleton(3L));
  assertThat(recs, hasSize(0));
  ResultList details = rec.recommendWithDetails(42, -1, null,
                         LongSets.singleton(3L));
  assertThat(details, hasSize(0));
}

@Test
public void testSingletonMap() {
  Long2DoubleMap map = LongUtils.flyweightMap(LongSets.singleton(42L), x -> x);
  assertThat(map.keySet(), hasSize(1));
  assertThat(map.keySet(), contains(42L));
  assertThat(map.size(), equalTo(1));
  assertThat(map.isEmpty(), equalTo(false));
  assertThat(map, hasEntry(42L, 42.0));
  assertThat(map.getOrDefault(10, Math.PI),
        equalTo(Math.PI));
  assertThat(map.get(10), equalTo(0.0));
}