Java LongList.add方法代码示例

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
/**
 * Build a random bipartite graph of given left and right sizes.
 *
 * @param leftSize   is the left hand size of the bipartite graph
 * @param rightSize  is the right hand size of the bipartite graph
 * @param random     is the random number generator to use for constructing the graph
 * @return a random bipartite graph
 */
public static StaticBipartiteGraph buildRandomBipartiteGraph(
    int leftSize, int rightSize, double edgeProbability, Random random) {
  Long2ObjectMap<LongList> leftSideGraph = new Long2ObjectOpenHashMap<LongList>(leftSize);
  Long2ObjectMap<LongList> rightSideGraph = new Long2ObjectOpenHashMap<LongList>(rightSize);
  int averageLeftDegree = (int) (rightSize * edgeProbability);
  int averageRightDegree = (int) (leftSize * edgeProbability);
  for (int i = 0; i < leftSize; i++) {
    leftSideGraph.put(i, new LongArrayList(averageLeftDegree));
    for (int j = 0; j < rightSize; j++) {
      if (random.nextDouble() < edgeProbability) {
        leftSideGraph.get(i).add(j);
        if (rightSideGraph.containsKey(j)) {
          rightSideGraph.get(j).add(i);
        } else {
          LongList rightSideList = new LongArrayList(averageRightDegree);
          rightSideList.add(i);
          rightSideGraph.put(j, rightSideList);
        }
      }
    }
  }

  return new StaticBipartiteGraph(leftSideGraph, rightSideGraph);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void readLongDeltaItShouldReadExpectedValues() throws IOException {
    final LongList expectedValues = new LongArrayList(new long[] {17L, 4L, 6L});
    /**
     * 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 LongList values = new LongArrayList();

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

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void readLongGammaItShouldReadExpectedValues() throws IOException {
    final LongList expectedValues = new LongArrayList(new long[] {17L, 4L, 6L});
    /**
     * 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 LongList values = new LongArrayList();

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

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void itShouldReadExpectedValues() throws IOException {
    final LongList expectedValues = new LongArrayList(new long[] {19L, Long.MAX_VALUE, -1});
    final int[] sizes = new int[] {5, 63, 64};
    final Helper.Input input = getInput(
        "10011" +
        "111111111111111111111111111111111111111111111111111111111111111" +
        "1111111111111111111111111111111111111111111111111111111111111111"
    );
    final InputBitStream inputStream = new InputBitStream(input.buffer);
    final LongList values = new LongArrayList();

    for (int i = 0; i < sizes.length; i++) {
        values.add(inputStream.readLong(sizes[i]));
    }

    assertEquals(expectedValues, values);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void whenThereIsAnEncodedNonEmptyIntervalsListItShouldRecoverOriginalIntervalsSuccessfully()
    throws Exception
{
    Helper.Input input = getInput(
        "01100 000000000000000000000000000000000000000000000000000000000000111 1 0101 1 1 0101"
    );
    final LongList expectedList = new LongArrayList(
        new long[] {7L, 8L, 9L, 10L, 14L, 15L, 16L, 17L, 19L, 20L, 21L, 22L, 23L, 24L}
    );
    final LongList list = new LongArrayList();

    IntervalIterator intervalIterator = new IntervalIterator(
        DefaultParametersValues.LONG_BITS,
        DefaultParametersValues.DEFAULT_MIN_INTERVAL_SIZE,
        input.stream
    );
    while (intervalIterator.hasNext()) {
        list.add(intervalIterator.next());
    }

    assertEquals(expectedList, list);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void whenThereIsAnEncodedEmptyIntervalsListItShouldRecoverOriginalIntervalsSuccessfully() throws Exception {
    Helper.Input input = getInput("1");
    final LongList expectedList = new LongArrayList(new long[] {});
    final LongList list = new LongArrayList();

    IntervalIterator intervalIterator = new IntervalIterator(
        DefaultParametersValues.LONG_BITS,
        DefaultParametersValues.DEFAULT_MIN_INTERVAL_SIZE,
        input.stream
    );
    while (intervalIterator.hasNext()) {
        list.add(intervalIterator.next());
    }

    assertEquals(expectedList, list);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void whenReferenceListFirstElementsMatchesWithListShouldRecoverListSegmentOnReferenceListSuccessfully()
    throws Exception
{
    final Helper.Input input = getInput("0100 0100 1 01100");
    final int listIndex = 1;
    final LongList referenceList = new LongArrayList(new long[] {1L, 2L, 3L, 5L, 9L, 12L, 13L});
    final LongList expectedList = new LongArrayList(new long[] {1L, 2L, 3L, 5L});
    final LongList list = new LongArrayList();

    ReferenceIterator referenceIterator = new ReferenceIteratorBuilder(input, listIndex, referenceList).build();
    while (referenceIterator.hasNext()) {
        list.add(referenceIterator.next());
    }

    assertEquals(expectedList, list);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void whenReferenceListLastElementsMatchesWithListShouldRecoverListSegmentOnReferenceListSuccessfully()
    throws Exception
{
    final Helper.Input input = getInput("0100 01100 0 1 0101 1");
    final int listIndex = 1;
    final LongList referenceList = new LongArrayList(new long[] {0L, 2L, 3L, 5L, 9L, 12L, 13L});
    final LongList expectedList = new LongArrayList(new long[] {2L, 3L, 5L, 12L, 13L});
    final LongList list = new LongArrayList();

    ReferenceIterator referenceIterator = new ReferenceIteratorBuilder(input, listIndex, referenceList).build();
    while (referenceIterator.hasNext()) {
        list.add(referenceIterator.next());
    }

    assertEquals(expectedList, list);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void whenThereIsAnEncodedRepetitionsListItShouldRecoverOriginalRepetitionsSuccessfully()
    throws Exception
{
    final int originalListSize = 16;
    Helper.Input input = getInput("01110 1 1 0100 0100 0100 1 0101 1 0100 1");
    /**
     * 1, 1, 2, 3, 3, 3, 5, 6, 6, 7, 10, 11, 11, 16, 19, 19 List from which the repetitions where extracted
     * 1, 0, 0, 1, 1, 0, 0, 1, 0, 0,  0,  1,  0,  0,  1,  0 Repetition flags
     */
    final LongList expectedRepetitions = new LongArrayList(
        new long[] {1L, 0L, 0L, 1L, 1L, 0L, 0L, 1L, 0L, 0L, 0L, 1L, 0L, 0L, 1L, 0L}
    );
    final LongList repetitions = new LongArrayList();

    RepeatsIterator repeatsIterator = new RepeatsIterator(input.stream);
    for(int i = 0; i < originalListSize; i++) {
       repetitions.add(repeatsIterator.next());
    }

    assertEquals(expectedRepetitions, repetitions);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void whenEncodedRepetitionsListIsEmptyItShouldRecoverOriginalRepetitionsSuccessfully()
    throws Exception
{
    final int originalListSize = 10;
    Helper.Input input = getInput("1");
    /**
     * 1, 2, 3, 5, 6, 7, 10, 11, 16, 19 List from which the repetitions where extracted
     * 0, 0, 0, 0, 0, 0,  0,  0,  0,  0 Repetition flags
     */
    final LongList expectedRepetitions = new LongArrayList(
        new long[] {0L, 0L, 0L, 0L, 0L, 0L, 0L ,0L ,0L, 0L}
    );
    final LongList repetitions = new LongArrayList();
    RepeatsIterator repeatsIterator = new RepeatsIterator(input.stream);
    for(int i = 0; i < originalListSize; i++) {
        repetitions.add(repeatsIterator.next());
    }

    assertEquals(expectedRepetitions, repetitions);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
public static LongList convertToLongList(OpenBitSet set) {
    LongList bits = new LongArrayList();
    long lastIndex = set.nextSetBit(0);
    while (lastIndex != -1) {
        bits.add(lastIndex);
        lastIndex = set.nextSetBit(lastIndex + 1);
    }
    return bits;
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Override
public void initialize(List<List<long[]>> tableSamplesList) {
    // Collect all column combinations that can be inserted.
    List<SimpleColumnCombination> combinations = new ArrayList<>();
    for (Map<SimpleColumnCombination, AD> hllsByColumnCombo : adByTable.values()) {
        combinations.addAll(hllsByColumnCombo.keySet());
    }
    for (int i = 0; i < combinations.size(); i++) {
        combinations.get(i).setIndex(i);
    }
    sampledInvertedIndex.setMaxId(combinations.size() - 1);

    // Now create according hashes from the table samples and initialize the inverted index with them.
    LongList samples = new LongArrayList();
    for (int table = 0; table < tableSamplesList.size(); table++) {
        Map<SimpleColumnCombination, AD> adByColumnCombinations = adByTable.get(table);
        if (adByColumnCombinations != null) {
            List<long[]> tableSamples = tableSamplesList.get(table);
            for (long[] sampleRow : tableSamples) {
                for (Map.Entry<SimpleColumnCombination, AD> entry : adByColumnCombinations.entrySet()) {
                    SimpleColumnCombination combination = entry.getKey();
                    long combinedHash = 0;
                    int[] columns = combination.getColumns();
                    boolean anyNull = false;
                    for (int i = 0; i < columns.length; i++) {
                        long hash = sampleRow[columns[i]];
                        if (anyNull = hash == HashedColumnStore.NULLHASH) break;
                        combinedHash = Long.rotateLeft(combinedHash, 1) ^ hash;
                    }
                    if (!anyNull) {
                        samples.add(combinedHash);
                    }
                }

            }
        }
    }
    sampledInvertedIndex.initialize(samples);
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Override
public EdgeIterator getRandomLeftNodeEdges(long leftNode, int numSamples, Random random) {
  LongList samples = new LongArrayList(numSamples);
  for (int i = 0; i < numSamples; i++) {
    LongList edges = leftSideGraph.get(leftNode);
    samples.add(edges.get(random.nextInt(edges.size())));
  }
  return new MockEdgeIterator(samples.iterator());
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Override
public EdgeIterator getRandomRightNodeEdges(long rightNode, int numSamples, Random random) {
  LongList samples = new LongArrayList(numSamples);
  for (int i = 0; i < numSamples; i++) {
    LongList edges = rightSideGraph.get(rightNode);
    samples.add(edges.get(random.nextInt(edges.size())));
  }
  return new MockEdgeIterator(samples.iterator());
}
 

import it.unimi.dsi.fastutil.longs.LongList; //导入方法依赖的package包/类
@Test
public void itShouldDecompressLists() throws IOException {
    final Input input = getInput(
        "1 1 1 01101 00101 0101 01100 1" +
        "0101 1 0100 0100 01100 0100 1 1 1 1"
    );
    final PebbleOffsetsStore offsetsStore = new LongListPebbleOffsetsStore(new long[] {0L, 23L});
    final PebbleBytesStore bytesStore = new BytesArrayPebbleBytesStore(input.buffer, offsetsStore);
    final int valueBitSize = 5;
    final LongList[] expectedLists = new LongList[] {
        new LongArrayList(new long[] {5L, 8L, 12L, 13L}),
        new LongArrayList(new long[] {5L, 5L, 5L, 8L, 12L, 12L, 12L, 12L, 12L, 13L})
    };
    final LongList[] lists = new LongList[expectedLists.length];
    LongList list;
    LongIterator iterator;

    for(int i = 0; i < lists.length; i++) {
        iterator = IncrementalListIterator.build(i, valueBitSize, bytesStore);
        lists[i] = list = new LongArrayList();
        while(iterator.hasNext()) {
            list.add(iterator.nextLong());
        }
    }

    assertEquals(
        Helper.<Long, LongList>translateToUtilsCollection(expectedLists),
        Helper.<Long, LongList>translateToUtilsCollection(lists)
    );
}