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

@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;
}
 

@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();
}
 

@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 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));
}
 

DoubleRawValueBasedInPredicateEvaluator(InPredicate inPredicate) {
  List<String> values = inPredicate.getValues();
  _matchingValues = new DoubleOpenHashSet(HashUtil.getMinHashSetSize(values.size()));
  for (String value : values) {
    _matchingValues.add(Double.parseDouble(value));
  }
}
 

@Test
public void testGetNext() {
	ThresholdFilter thresholdFilter = new StepThresholdFilter(
		Arrays.asList(Double.valueOf(0.9), Double.valueOf(0.8), Double.valueOf(0.4), Double.valueOf(0.7)));
	Iterable<Double> thresholds = thresholdFilter
		.filter(new DoubleOpenHashSet(Sets.newHashSet(Double.valueOf(0.7), Double.valueOf(0.6))));
	assertThat(thresholds).hasSize(4);
	assertThat(thresholds).contains(Double.valueOf(0.9), Double.valueOf(0.8), Double.valueOf(0.4), Double.valueOf(0.7));
}
 

DoubleRawValueBasedNotInPredicateEvaluator(NotInPredicate notInPredicate) {
  List<String> values = notInPredicate.getValues();
  _nonMatchingValues = new DoubleOpenHashSet(HashUtil.getMinHashSetSize(values.size()));
  for (String value : values) {
    _nonMatchingValues.add(Double.parseDouble(value));
  }
}
 

@Test
public void testGetNext() {
	ThresholdFilter thresholdFilter = new ExactThresholdFilter();
	Iterable<Double> thresholds = thresholdFilter
		.filter(new DoubleOpenHashSet(Sets.newHashSet(Double.valueOf(0.7), Double.valueOf(0.6))));
	assertThat(thresholds).hasSize(2);
	assertThat(thresholds).contains(Double.valueOf(0.7), Double.valueOf(0.6));
}
 

@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 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 int countUnique() {
  DoubleSet uniqueElements = new DoubleOpenHashSet();
  for (int i = 0; i < size(); i++) {
    uniqueElements.add(getDouble(i));
  }
  return uniqueElements.size();
}
 

@BeforeClass
public void setUp()
    throws Exception {
  FileUtils.deleteQuietly(TEMP_DIR);

  IntOpenHashSet intSet = new IntOpenHashSet();
  while (intSet.size() < NUM_VALUES) {
    intSet.add(RANDOM.nextInt());
  }
  _intValues = intSet.toIntArray();
  Arrays.sort(_intValues);

  LongOpenHashSet longSet = new LongOpenHashSet();
  while (longSet.size() < NUM_VALUES) {
    longSet.add(RANDOM.nextLong());
  }
  _longValues = longSet.toLongArray();
  Arrays.sort(_longValues);

  FloatOpenHashSet floatSet = new FloatOpenHashSet();
  while (floatSet.size() < NUM_VALUES) {
    floatSet.add(RANDOM.nextFloat());
  }
  _floatValues = floatSet.toFloatArray();
  Arrays.sort(_floatValues);

  DoubleOpenHashSet doubleSet = new DoubleOpenHashSet();
  while (doubleSet.size() < NUM_VALUES) {
    doubleSet.add(RANDOM.nextDouble());
  }
  _doubleValues = doubleSet.toDoubleArray();
  Arrays.sort(_doubleValues);

  Set<String> stringSet = new HashSet<>();
  while (stringSet.size() < NUM_VALUES) {
    stringSet.add(RandomStringUtils.random(RANDOM.nextInt(MAX_STRING_LENGTH)).replace('\0', ' '));
  }
  _stringValues = stringSet.toArray(new String[NUM_VALUES]);
  Arrays.sort(_stringValues);

  Set<ByteArray> bytesSet = new HashSet<>();
  while (bytesSet.size() < NUM_VALUES) {
    byte[] bytes = new byte[BYTES_LENGTH];
    RANDOM.nextBytes(bytes);
    bytesSet.add(new ByteArray(bytes));
  }
  _bytesValues = bytesSet.toArray(new ByteArray[NUM_VALUES]);
  Arrays.sort(_bytesValues);

  try (SegmentDictionaryCreator dictionaryCreator = new SegmentDictionaryCreator(_intValues,
      new DimensionFieldSpec(INT_COLUMN_NAME, FieldSpec.DataType.INT, true), TEMP_DIR)) {
    dictionaryCreator.build();
  }

  try (SegmentDictionaryCreator dictionaryCreator = new SegmentDictionaryCreator(_longValues,
      new DimensionFieldSpec(LONG_COLUMN_NAME, FieldSpec.DataType.LONG, true), TEMP_DIR)) {
    dictionaryCreator.build();
  }

  try (SegmentDictionaryCreator dictionaryCreator = new SegmentDictionaryCreator(_floatValues,
      new DimensionFieldSpec(FLOAT_COLUMN_NAME, FieldSpec.DataType.FLOAT, true), TEMP_DIR)) {
    dictionaryCreator.build();
  }

  try (SegmentDictionaryCreator dictionaryCreator = new SegmentDictionaryCreator(_doubleValues,
      new DimensionFieldSpec(DOUBLE_COLUMN_NAME, FieldSpec.DataType.DOUBLE, true), TEMP_DIR)) {
    dictionaryCreator.build();
  }

  try (SegmentDictionaryCreator dictionaryCreator = new SegmentDictionaryCreator(_stringValues,
      new DimensionFieldSpec(STRING_COLUMN_NAME, FieldSpec.DataType.STRING, true), TEMP_DIR)) {
    dictionaryCreator.build();
    _numBytesPerStringValue = dictionaryCreator.getNumBytesPerEntry();
  }

  try (SegmentDictionaryCreator dictionaryCreator = new SegmentDictionaryCreator(_bytesValues,
      new DimensionFieldSpec(BYTES_COLUMN_NAME, FieldSpec.DataType.BYTES, true), TEMP_DIR)) {
    dictionaryCreator.build();
    assertEquals(dictionaryCreator.getNumBytesPerEntry(), BYTES_LENGTH);
  }
}
 

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

@Test
public void testEmpty() {
	ThresholdFilter thresholdFilter = new ExactThresholdFilter();
	Iterable<Double> thresholds = thresholdFilter.filter(new DoubleOpenHashSet());
	assertThat(thresholds).isEmpty();
}
 

@Test
public void testEmpty() {
	ThresholdFilter thresholdFilter = new StepThresholdFilter(Collections.emptyList());
	Iterable<Double> thresholds = thresholdFilter.filter(new DoubleOpenHashSet());
	assertThat(thresholds).isEmpty();
}
 

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