it.unimi.dsi.fastutil.doubles.DoubleSet Java Examples

@Nullable
public static <T> T getWeightedRandomReversed(Random random, Double2ObjectMap<T> choices)
{
    double i = 0;
    DoubleSet doubles = choices.keySet();
    for (DoubleIterator iterator = doubles.iterator(); iterator.hasNext(); )
    {
        double x = iterator.nextDouble();
        i += x;
    }
    i = getRandomDouble(random, 0, i);
    for (Double2ObjectMap.Entry<T> entry : choices.double2ObjectEntrySet())
    {
        i -= entry.getDoubleKey();
        if (i < 0)
        {
            return entry.getValue();
        }
    }
    return null;
}
 

@Override
public Iterable<Double> filter(DoubleSet similarities) {
	if (similarities.isEmpty()) {
		return DoubleSets.EMPTY_SET;
	}
	DoubleSortedSet filtered = sorted(similarities);
	double first = filtered.firstDouble();
	int intervals = size - 1;
	if (intervals == 0) {
		return DoubleSets.singleton(first);
	}
	double last = filtered.lastDouble();
	double intervalSize = (first - last) / intervals;
	UniformTrimmer trimmer = new UniformTrimmer(intervalSize);
	OfDouble iterator = filtered.iterator();
	trimmer.trim(iterator);
	return filtered;
}
 

private static double[] filterDoubles(DoubleSet doubleSet, double[] source) {
  DoubleList doubleList = new DoubleArrayList();
  for (double value : source) {
    if (doubleSet.contains(value)) {
      doubleList.add(value);
    }
  }
  if (doubleList.size() == source.length) {
    return source;
  } else {
    return doubleList.toDoubleArray();
  }
}
 

@Override
public int countUnique() {
  DoubleSet uniqueElements = new DoubleOpenHashSet();
  for (int i = 0; i < size(); i++) {
    uniqueElements.add(getDouble(i));
  }
  return uniqueElements.size();
}
 

@Override
public DoubleColumn unique() {
  final DoubleSet doubles = new DoubleOpenHashSet();
  for (int i = 0; i < size(); i++) {
    doubles.add(getDouble(i));
  }
  final DoubleColumn column = DoubleColumn.create(name() + " Unique values");
  doubles.forEach((DoubleConsumer) column::append);
  return column;
}
 

@Override
public DoubleSet values() {
	DoubleSet result = new DoubleOpenHashSet();
	Arrays.stream(array)
		.filter(Objects::nonNull)
		.map(Int2DoubleRow::values)
		.flatMap(DoubleCollection::stream)
		.mapToDouble(Double::doubleValue)
		.forEach(result::add);
	return result;
}
 

@Override
public int countUnique() {
  DoubleSet uniqueElements = new DoubleOpenHashSet();
  for (int i = 0; i < size(); i++) {
    uniqueElements.add(getDouble(i));
  }
  return uniqueElements.size();
}
 

@Override
public DoubleColumn unique() {
  final DoubleSet doubles = new DoubleOpenHashSet();
  for (int i = 0; i < size(); i++) {
    doubles.add(getDouble(i));
  }
  final DoubleColumn column = DoubleColumn.create(name() + " Unique values");
  doubles.forEach((DoubleConsumer) column::append);
  return column;
}
 

@Test
public void testExact() {
	ThresholdFilter thresholdFilter = new UniformDistributionThresholdProviderThresholdFilter(3,
		new ExactThresholdFilter());
	DoubleSet similarities = new DoubleOpenHashSet(new double[]{0.2, 0.3, 0.4, 0.5, 0.6});
	Iterable<Double> thresholds = thresholdFilter.filter(similarities);
	assertThat(thresholds).hasSize(3);
	assertThat(thresholds).contains(Double.valueOf(0.2), Double.valueOf(0.4), Double.valueOf(0.6));
}
 

@Test
public void test() {
	ThresholdFilter thresholdFilter = new UniformDistributionThresholdProviderThresholdFilter(3,
		new ExactThresholdFilter());
	DoubleSet similarities = new DoubleOpenHashSet(new double[]{0.2, 0.3, 0.4, 0.5});
	Iterable<Double> thresholds = thresholdFilter.filter(similarities);
	assertThat(thresholds).hasSize(3);
	assertThat(thresholds).contains(Double.valueOf(0.2), Double.valueOf(0.3), Double.valueOf(0.5));
}
 

@Test
public void testGetNext() {
	List<DoubleSet> similarities = Arrays
		.asList(new DoubleOpenHashSet(Sets.newHashSet(Double.valueOf(0.7), Double.valueOf(0.6))),
			new DoubleOpenHashSet(Sets.newHashSet(Double.valueOf(0.8))));
	ThresholdProvider provider = create(similarities);
	assertThat(provider.getNext(0, 0.5).boxed()).hasValue(Double.valueOf(0.6));
	assertThat(provider.getNext(0, 0.6).boxed()).hasValue(Double.valueOf(0.7));
	assertThat(provider.getNext(1, 0.8).boxed()).isEmpty();
}
 

@Override
public DoubleSet filter(DoubleSet similarities) {
	return similarities;
}
 

@Test
public void testEmpty() {
	List<DoubleSet> similarities = Collections.singletonList(new DoubleOpenHashSet());
	ThresholdProvider provider = create(similarities);
	assertThat(provider.getNext(0, 0.0).boxed()).isEmpty();
}
 

private static ThresholdProvider create(Iterable<DoubleSet> similarities) {
	return MultiThresholdProvider.create(similarities);
}
 

@Override
public Iterable<Double> filter(DoubleSet similarities) {
	return LimitSizeUtils.limitSize(similarities, size);
}
 

public static Iterable<Double> limitSize(DoubleCollection similarities, int size) {
	DoubleSet filtered = ThresholdFilterUtils.sorted(similarities);
	Trimmer trimmer = new Trimmer(size);
	trimmer.trim(filtered);
	return filtered;
}
 

@Override
public Iterable<Double> filter(DoubleSet similarities) {
	return steps;
}
 

@Override
public Iterable<Double> getThresholds(ThresholdFilter thresholdFilter) {
	DoubleSet similarities = similarityIndex.getSimilarities();
	return thresholdFilter.filter(similarities);
}
 

@Override
public DoubleSet getSimilarities() {
	return similarityTable.values();
}
 

@Override
public DoubleSet getSimilarities() {
	Collection<Double> values = similarityTable.values();
	return new DoubleOpenHashSet(values);
}
 

DoubleSet getSimilarities(); 

Iterable<Double> filter(DoubleSet similarities); 

DoubleSet values();