it.unimi.dsi.fastutil.ints.IntIterable Java Examples

@Override
public void validate(Iterable<int[]> leftMatches, IntIterable right) {
	Int2ObjectMultimap<int[]> grouped = groupByValue(leftMatches);
	Iterator<Entry<Collection<int[]>>> it = grouped.iterator();
	while (it.hasNext() && shouldUpdate()) {
		Entry<Collection<int[]>> entry = it.next();
		int value = entry.getIntKey();
		Collection<int[]> records = entry.getValue();
		threshold = updateThreshold(value, records, right);
	}
}
 

@Override
public void validate(int[] record, IntIterable right) {
	if (shouldUpdate()) {
		int leftValue = getLeftValue(record);
		Collection<int[]> records = Collections.singletonList(record);
		threshold = updateThreshold(leftValue, records, right);
	}
}
 

private Int2ObjectMultimap<int[]> groupByValue(IntIterable matching) {
	Int2ObjectMultimap<int[]> map = new Int2ObjectHashMultimap<>();
	OfInt it = matching.iterator();
	while (it.hasNext()) {
		int id = it.nextInt();
		int[] right = getRightRecord(id);
		int rightValue = getRightValue(right);
		map.put(rightValue, right);
	}
	return map;
}
 

@Override
public double calculateMinSimilarity(IntIterable matching) {
	OfInt it = matching.iterator();
	//does order have an impact on runtime?
	while (it.hasNext() && shouldUpdate(minSimilarity)) {
		int id = it.nextInt();
		updateMinSimilarity(id);
	}
	return minSimilarity;
}
 

@Override
public void validate(Iterable<int[]> leftMatches, IntIterable right) {
	// do nothing because we already know the result
}
 

@Override
public void validate(int[] record, IntIterable right) {
	// do nothing because we already know the result
}
 

private double calculateMinSimilarity(int value, Collection<int[]> records,
	IntIterable matching) {
	return with(value, records).calculateMinSimilarity(matching);
}
 

private double updateThreshold(int value, Collection<int[]> records, IntIterable matching) {
	double minSimilarity = calculateMinSimilarity(value, records, matching);
	return Math.min(threshold, minSimilarity);
}
 

@Override
public double calculateMinSimilarity(IntIterable matching) {
	Int2ObjectMultimap<int[]> map = groupByValue(matching);
	return calculateMinSimilarity(map);
}
 

private Stream<Tuple2<Selector, Collection<int[]>>> process(IntIterable records) {
	records.forEach((IntConsumer) this::process);
	return getGroups();
}
 

abstract double calculateMinSimilarity(IntIterable matching); 

void validate(Iterable<int[]> left, IntIterable right); 

void validate(int[] record, IntIterable right);