Java IntList.size方法代码示例

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
private List<double[]> getNeighbors(int curIndex, IntList svdIndices,
                                    SVDFeature svdFeature,
                                    List<String> features) {
    List<double[]> raw = new ArrayList<>(svdIndices.size());
    for (int target : svdIndices) {
        if (target != curIndex && (numMatch == 0 || matchPrefixFeatures(curIndex, target, features))) {
            double[] pair = new double[2];
            pair[0] = target;
            pair[1] = svdFeature.getVectorVarByNameIndex(SVDFeatureKey.FACTORS.get(), target)
                    .cosine(svdFeature.getVectorVarByNameIndex(SVDFeatureKey.FACTORS.get(), curIndex));
            raw.add(pair);
        }
    }
    Ordering<double[]> pairDoubleOrdering = SortingUtilities.pairDoubleSecondOrdering();
    List<double[]> neighbors;
    if (reverse) {
        neighbors = pairDoubleOrdering.leastOf(raw, numNeighbors);
    } else {
        neighbors = pairDoubleOrdering.greatestOf(raw, numNeighbors);
    }
    return neighbors;
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
/**
 * Returns the permutation to obtain the re-ranking
 *
 * @return permutation to obtain the re-ranking
 */
public int[] rerankPermutation() {

    List<Tuple2od<I>> list = recommendation.getItems();

    IntList perm = new IntArrayList();
    IntLinkedOpenHashSet remainingI = new IntLinkedOpenHashSet();
    IntStream.range(0, list.size()).forEach(remainingI::add);

    while (!remainingI.isEmpty() && perm.size() < min(maxLength, cutoff)) {
        int bestI = selectItem(remainingI, list);

        perm.add(bestI);
        remainingI.remove(bestI);

        update(list.get(bestI));
    }

    while (perm.size() < min(maxLength, list.size())) {
        perm.add(remainingI.removeFirstInt());
    }

    return perm.toIntArray();
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
@Test
public void readDeltaItShouldReadExpectedValues() throws IOException {
    final IntList expectedValues = new IntArrayList(new int[] {17, 4, 6});
    /**
     * 18        5     7     Increment one.
     * 10010     101   111   Binary representation.
     * 5-0010    3-01  3-11  Decimal Gamma Prefix and Binary Gamma Suffix.
     * 101-0010  11-01 11-11 Binary Gamma Prefix and Binary Gamma Suffix.
     * 001010010 01101 01111 Delta Encoding.
     */
    final Helper.Input input = getInput("001010010 01101 01111");
    final InputBitStream inputStream = new InputBitStream(input.buffer);
    final IntList values = new IntArrayList();

    for (int i = 0; i < expectedValues.size(); i++) {
        values.add(inputStream.readDelta());
    }

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
@Test
public void readGammaItShouldReadExpectedValues() throws IOException {
    final IntList expectedValues = new IntArrayList(new int[] {17, 4, 6});
    /**
     * 18        5     7     Increment one.
     * 10010     101   111   Binary representation.
     * 5-0010    3-01  3-11  Decimal Gamma Prefix and Binary Gamma Suffix.
     * 000010010 00101 00111 Gamma Encoding.
     */
    final Helper.Input input = getInput("000010010 00101 00111");
    final InputBitStream inputStream = new InputBitStream(input.buffer);
    final IntList values = new IntArrayList();

    for (int i = 0; i < expectedValues.size(); i++) {
        values.add(inputStream.readGamma());
    }

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
private static boolean checkNoProvoking(IntList indices, int faceSize, int pos) {
	int usedId=indices.getInt(pos);
	for(int i=0;i<indices.size();i+=faceSize) {
		if(indices.getInt(i)==usedId)return false;
	}
	return true;
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
public static float[] uncompress(float[] dest, FloatList data, IntList indices, int partSize){
	int counter=0;
	for(int i=0;i<indices.size();i++){
		int pos=indices.getInt(i)*partSize;
		
		for(int j=0;j<partSize;j++){
			dest[counter++]=data.getFloat(pos+j);
		}
	}
	
	return dest;
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
private void increaseMeasure(final IntList measureList, final int level) {
  if (measureList.size() > level - 1) {
    final int prev = measureList.getInt(level - 1);
    measureList.set(level - 1, prev + 1);
  } else {
    final int skippedLevels = level - measureList.size() - 1;
    // add 0 for no application of the pruning rule in the skipped levels
    for (int i = 0; i < skippedLevels; i++) {
      measureList.add(0);
    }
    // add 1 for one application of the pruning rule in the new level
    measureList.add(1);
  }
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
private void doRecusiveCrap(int currentAttribute, IntList currentOrdering, List<DifferenceSet> setsNotCovered,
                            IntList currentPath, List<DifferenceSet> originalDiffSet, List<FunctionalDependencyGroup2> result)
        throws CouldNotReceiveResultException, ColumnNameMismatchException {

    // Basic Case
    // FIXME
    if (!currentOrdering.isEmpty() && /* BUT */setsNotCovered.isEmpty()) {
        if (this.debugSysout)
            System.out.println("no FDs here");
        return;
    }

    if (setsNotCovered.isEmpty()) {

        List<OpenBitSet> subSets = this.generateSubSets(currentPath);
        if (this.noOneCovers(subSets, originalDiffSet)) {
            FunctionalDependencyGroup2 fdg = new FunctionalDependencyGroup2(currentAttribute, currentPath);
            this.addFdToReceivers(fdg);
            result.add(fdg);
        } else {
            if (this.debugSysout) {
                System.out.println("FD not minimal");
                System.out.println(new FunctionalDependencyGroup2(currentAttribute, currentPath));
            }
        }

        return;
    }

    // Recusive Case
    for (int i = 0; i < currentOrdering.size(); i++) {

        List<DifferenceSet> next = this.generateNextNotCovered(currentOrdering.getInt(i), setsNotCovered);
        IntList nextOrdering = this.generateNextOrdering(next, currentOrdering, currentOrdering.getInt(i));
        IntList currentPathCopy = new IntArrayList(currentPath);
        currentPathCopy.add(currentOrdering.getInt(i));
        this.doRecusiveCrap(currentAttribute, nextOrdering, next, currentPathCopy, originalDiffSet, result);
    }

}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
private int sum(IntList list) {
	int result = 0;
	int size = list.size();
	for (int i = 0; i < size; ++i) {
		result += list.getInt(i);
	}
	return result;
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
/**
 * Adds to the store the <code>list</code>. In case the store is full it will overwrite the oldest list on the
 * store.
 *
 * @param offset position of the <code>list</code> respect to the list of lists, starting from zero.
 * @param recursiveReferences number of recursive reference of the <code>list</code>.
 * @param list to append to the store.
 * @return true when the <code>list</code> is added to the store and false when is not.
 */
public boolean add(final int offset, final int recursiveReferences, final IntList list) {
    if (recursiveReferences <= maxRecursiveReferences && minListSize <= list.size()) {
        if (lists[index] != null) {
            referenceListIndex.removeListFromListsInvertedIndex(index, lists[index]);
        }
        this.recursiveReferences[index] = recursiveReferences;
        offsets[index] = offset;
        lists[index] = new IntArrayList(list);
        referenceListIndex.addListIntoListsInvertedIndex(index, lists[index]);
        index = (index + 1) % offsets.length;
        return true;
    }
    return false;
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
@Test
public void readUnaryItShouldReadExpectedValues() throws IOException {
    final IntList expectedValues = new IntArrayList(new int[] {17, 4, 6});
    final Helper.Input input = getInput("00000000000000001 0001 000001");
    final InputBitStream inputStream = new InputBitStream(input.buffer);
    final IntList values = new IntArrayList();

    for (int i = 0; i < expectedValues.size(); i++) {
        values.add(inputStream.readUnary());
    }

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
@Test
public void itShouldReadExpectedValues() throws IOException {
    final IntList expectedValues = new IntArrayList(new int[] {1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1});
    final Helper.Input input = getInput("1 1 0 1 0 0 1 0 0 0 0 1");
    final InputBitStream inputStream = new InputBitStream(input.buffer);
    final IntList values = new IntArrayList();

    for (int i = 0; i < expectedValues.size(); i++) {
        values.add(inputStream.readBit());
    }

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
private IntList generateNextOrdering(List<DifferenceSet> next, IntList currentOrdering, int attribute) {

        IntList result = new IntArrayList();

        Int2IntMap counting = new Int2IntArrayMap();
        boolean seen = false;
        for (int i = 0; i < currentOrdering.size(); i++) {

            if (!seen) {
                if (currentOrdering.getInt(i) != attribute) {
                    continue;
                } else {
                    seen = true;
                }
            } else {

                counting.put(currentOrdering.getInt(i), 0);
                for (DifferenceSet ds : next) {

                    if (ds.getAttributes().get(currentOrdering.getInt(i))) {
                        counting.put(currentOrdering.getInt(i), counting.get(currentOrdering.getInt(i)) + 1);
                    }
                }
            }
        }

        // TODO: Comperator und TreeMap --> Tommy
        while (true) {

            if (counting.size() == 0) {
                break;
            }

            int biggestAttribute = -1;
            int numberOfOcc = 0;
            for (int attr : counting.keySet()) {

                if (biggestAttribute < 0) {
                    biggestAttribute = attr;
                    numberOfOcc = counting.get(attr);
                    continue;
                }

                int tempOcc = counting.get(attr);
                if (tempOcc > numberOfOcc) {
                    numberOfOcc = tempOcc;
                    biggestAttribute = attr;
                } else if (tempOcc == numberOfOcc) {
                    if (biggestAttribute > attr) {
                        biggestAttribute = attr;
                    }
                }
            }

            if (numberOfOcc == 0) {
                break;
            }

            result.add(biggestAttribute);
            counting.remove(biggestAttribute);
        }

        return result;
    }
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
public void add(IntList idxList, List<double[]> resps) {
    for (int i=0; i<idxList.size(); i++) {
        add(idxList.getInt(i), resps);
    }
}
 

import it.unimi.dsi.fastutil.ints.IntList; //导入方法依赖的package包/类
public void remove(IntList idxList, List<double[]> resps) {
    for (int i=0; i<idxList.size(); i++) {
        remove(idxList.getInt(i), resps);
    }
}