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

@Timed
public IntCollection findLhsMatches(Selector selector) {
	Collection<IntCollection> clusters = emptyList();
	int i = 0;
	for (ColumnPairWithThreshold pair : lhs) {
		int value = selector.get(i);
		IntCollection cluster = pair.getMatching(value);
		if (cluster.isEmpty()) {
			return IntLists.EMPTY_LIST;
		}
		clusters.add(cluster);
		i++;
	}
	return CollectionUtils.intersection(clusters)
		.orElseGet(rightRecords::getAll);
}
 

@Nullable
public static <T> T getWeightedRandom(Random random, Object2IntMap<T> choices)
{
    long i = 0;
    IntCollection ints = choices.values();
    for (IntIterator iterator = ints.iterator(); iterator.hasNext(); )
    {
        int x = iterator.nextInt();
        i += x;
    }
    i = getRandomLong(random, 0, i);
    for (Object2IntMap.Entry<T> entry : choices.object2IntEntrySet())
    {
        i -= entry.getIntValue();
        if (i < 0)
        {
            return entry.getKey();
        }
    }
    return null;
}
 

/**
 * 移除map中符合条件的元素，并对删除的元素执行后续的操作。
 *
 * @param collection 必须是可修改的集合
 * @param predicate  过滤条件，为真的删除
 * @param then       元素删除之后执行的逻辑
 * @return 删除的元素数量
 */
public static int removeIfAndThen(IntCollection collection, IntPredicate predicate, IntConsumer then) {
    if (collection.size() == 0) {
        return 0;
    }
    final IntIterator itr = collection.iterator();
    int value;
    int removeNum = 0;
    while (itr.hasNext()) {
        value = itr.nextInt();
        if (predicate.test(value)) {
            itr.remove();
            removeNum++;
            then.accept(value);
        }
    }
    return removeNum;
}
 

public void remove(T key, int value) {
    IntCollection collection = map.get(key);
    if (collection != null) {
        collection.rem(value);
        if (collection.isEmpty()) {
            map.remove(key);
        }
    }
}
 

@Timed
	private long validate(Selector selector, Collection<int[]> left) {
		IntCollection rightMatches = intersector.findLhsMatches(selector);
//		log.trace("Validating {} left matches with {} right matches", left.size(),
//			rightMatches.size());
		rhs.forEach(rhsTask -> rhsTask.validate(left, rightMatches));
		return (long) left.size() * rightMatches.size();
	}
 

private IntCollection getSimilarRecords(int leftValue) {
	Int2DoubleMap row = similarityTable.row(leftValue).asMap();
	IntCollection result = new IntArrayList();
	Seq.seq(row.int2DoubleEntrySet())
		.filter(this::isAbove)
		.map(this::getRecords)
		.forEach(result::addAll);
	return result;
}
 

private DataSet SparseToDense(int batchSize, int start){
	
	if(isRandomised == false){
		randomiseDatacaseIndex();
	}
	/*
	 *  convert from sparse to dense
	 */
	
	// create a dataset over variables corresponding to the external IDs
	DataSet Dense = new DataSet(_VariablesSet);
	
	// adding datacases
	for(int i = start ; i < batchSize + start ; i++){
		
		int[] states = new int[_VariablesSet.length];
		IntCollection row = SDataSet.userMatrix().get(_randomToOriginalDataCaseIndexMap.get(i));
		
		// Filling in the positive entries
		IntIterator iter = row.iterator();
		while(iter.hasNext()){
		    int internal_ID = iter.nextInt(); // the id of the item
		    String name = _item_mapping.toOriginalID(internal_ID);
		    states[_mapNameToIndex.get(name)] = 1;
		}
		Dense.addDataCase(states, 1);
		
	}
	
	return Dense;
}
 

@Test
public void testIntersection() {
	List<IntCollection> clusters = ImmutableList.<IntCollection>builder()
		.add(new IntOpenHashSet(Arrays.asList(1, 2, 3, 4)))
		.add(new IntOpenHashSet(Arrays.asList(2, 3, 4, 5)))
		.add(new IntOpenHashSet(Arrays.asList(1, 3, 4)))
		.build();
	Assert.assertThat(CollectionUtils.intersection(clusters), isPresentAnd(hasSize(2)));
	Assert.assertThat(CollectionUtils.intersection(clusters), isPresentAnd(hasItems(3, 4)));
}
 

@Test
public void testEmptyAfterIntersection() {
	List<IntCollection> clusters = ImmutableList.<IntCollection>builder()
		.add(new IntOpenHashSet(Arrays.asList(1, 2, 3, 4)))
		.add(new IntOpenHashSet(Arrays.asList(2, 3, 4, 5)))
		.add(new IntOpenHashSet(Arrays.asList(1, 3, 4)))
		.add(new IntOpenHashSet(Arrays.asList(1, 5)))
		.build();
	Assert.assertThat(CollectionUtils.intersection(clusters), isPresentAnd(empty()));
}
 

private long validate(IntCollection leftMatches, IntCollection rightMatches) {
	log.trace("Validating {} left matches with {} right matches", Integer.valueOf(leftMatches.size()),
		Integer.valueOf(rightMatches.size()));
	Iterable<int[]> left = getRecords(leftMatches);
	rhs.forEach(rhsTask -> rhsTask.validate(left, rightMatches));
	return (long) leftMatches.size() * rightMatches.size();
}
 

private Iterable<int[]> getRecords(IntCollection leftMatches) {
	int size = leftMatches.size();
	Collection<int[]> left = new ArrayList<>(size);
	OfInt it = leftMatches.iterator();
	while (it.hasNext()) {
		int leftId = it.nextInt();
		int[] record = leftRecords.get(leftId);
		left.add(record);
	}
	return left;
}
 

private IntCollection collect(Double2ObjectMap<IntSet> sortedMap, double max) {
	//this function seems to be the most crucial part of the code
	for (Entry<IntSet> entry : sortedMap.double2ObjectEntrySet()) {
		double threshold = entry.getDoubleKey();
		if (threshold < max) {
			// thresholds are sorted descending
			break;
		}
		IntSet value = entry.getValue();
		result.addAll(value);
	}
	return result;
}
 

@Override
public IntCollection greaterOrEqual(int valueId, double max) {
	if (useCache) {
		GreaterOrEqualCall call = new GreaterOrEqualCall(valueId, max);
		LoadingCache<GreaterOrEqualCall, IntCollection> cache = getCache();
		return cache.getUnchecked(call);
	}
	return greaterOrEqual_(valueId, max);
}
 

Iterable<int[]> getRecords(IntCollection ids) {
	int size = ids.size();
	Collection<int[]> result = new ArrayList<>(size);
	OfInt it = ids.iterator();
	while (it.hasNext()) {
		int id = it.nextInt();
		int[] record = records.get(id);
		result.add(record);
	}
	return result;
}
 

private CompressedEnforceMatch enforce(IntCollection leftMatches, IntCollection rightMatches) {
	Iterable<int[]> left = leftRecords.getRecords(leftMatches);
	Iterable<int[]> right = rightRecords.getRecords(rightMatches);
	return new CompressedEnforceMatch(left, right);
}
 

private CompressedEnforceMatch enforce(Cluster entry) {
	int value = entry.getValue();
	IntCollection leftMatches = entry.getRecords();
	IntCollection rightMatches = columnPair.getAllSimilarRightRecords(value, threshold);
	return enforce(leftMatches, rightMatches);
}
 

public static Optional<IntCollection> intersection(Collection<IntCollection> clusters) {
	//shrink result as early as possible
	List<IntCollection> sorted = sort(clusters, CLUSTER_COMPARATOR);
	return createIntersector(sorted).map(HeadAndTailIntersector::intersect);
}
 

private CompressedEnforceMatch enforce(Selector selector, Collection<int[]> left) {
	IntCollection rightMatches = intersector.findLhsMatches(selector);
	Iterable<int[]> right = rightRecords.getRecords(rightMatches);
	return new CompressedEnforceMatch(left, right);
}
 

private Collection<IntCollection> emptyList() {
	int size = lhs.size();
	return new ArrayList<>(size);
}
 

IntCollection getMatching(int value) {
	return columnPair.getAllSimilarRightRecords(value, threshold);
}
 

public static HeadAndTailIntersector create(IntCollection head,
	Collection<IntCollection> tail) {
	IntArrayList result = createResult(head);
	return new HeadAndTailIntersector(head, tail, result);
}
 

public IntCollection intersect() {
	IntConsumer addIfInTail = this::addIfInTail;
	head.forEach(addIfInTail);
	return result;
}
 

private boolean contains(IntCollection cluster) {
	return cluster.contains(match);
}
 

private void validate(Cluster cluster) {
	int value = cluster.getValue();
	IntCollection leftMatches = cluster.getRecords();
	IntCollection rightMatches = columnPair.getAllSimilarRightRecords(value, threshold);
	support += validate(leftMatches, rightMatches);
}
 

public static IntSet merge(IntSet left, IntCollection right) {
	left.addAll(right);
	return left;
}
 

public static IntCollection merge(IntCollection left, IntCollection right) {
	left.addAll(right);
	return left;
}
 

private static Optional<HeadAndTailIntersector> createIntersector(
	List<IntCollection> clusters) {
	return with(clusters).create();
}
 

private static WithClusters with(List<IntCollection> clusters) {
	return new WithClusters(clusters);
}
 

private HeadAndTailIntersector create(IntCollection head) {
	Collection<IntCollection> tail = tail(clusters);
	return HeadAndTailIntersector.create(head, tail);
}
 

public boolean contains(T key, int value) {
    IntCollection collection = map.get(key);
    return collection != null && collection.contains(value);
}