target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void trim() { MappeableContainer rc = new MappeableRunContainer(10); rc = rc.add(1, 5); rc.trim(); assertEquals(4, rc.getCardinality()); for (int i = 1; i < 5; i++) { assertTrue(rc.contains((char) i)); } } | @Override public void trim() { if (valueslength.limit() == 2 * nbrruns) { return; } if (BufferUtil.isBackedBySimpleArray(valueslength)) { this.valueslength = CharBuffer.wrap(Arrays.copyOf(valueslength.array(), 2 * nbrruns)); } else { final CharBuffer co = CharBuffer.allocate(2 * nbrruns); char[] a = co.array(); for (in... | MappeableRunContainer extends MappeableContainer implements Cloneable { @Override public void trim() { if (valueslength.limit() == 2 * nbrruns) { return; } if (BufferUtil.isBackedBySimpleArray(valueslength)) { this.valueslength = CharBuffer.wrap(Arrays.copyOf(valueslength.array(), 2 * nbrruns)); } else { final CharBuff... | MappeableRunContainer extends MappeableContainer implements Cloneable { @Override public void trim() { if (valueslength.limit() == 2 * nbrruns) { return; } if (BufferUtil.isBackedBySimpleArray(valueslength)) { this.valueslength = CharBuffer.wrap(Arrays.copyOf(valueslength.array(), 2 * nbrruns)); } else { final CharBuff... | MappeableRunContainer extends MappeableContainer implements Cloneable { @Override public void trim() { if (valueslength.limit() == 2 * nbrruns) { return; } if (BufferUtil.isBackedBySimpleArray(valueslength)) { this.valueslength = CharBuffer.wrap(Arrays.copyOf(valueslength.array(), 2 * nbrruns)); } else { final CharBuff... | MappeableRunContainer extends MappeableContainer implements Cloneable { @Override public void trim() { if (valueslength.limit() == 2 * nbrruns) { return; } if (BufferUtil.isBackedBySimpleArray(valueslength)) { this.valueslength = CharBuffer.wrap(Arrays.copyOf(valueslength.array(), 2 * nbrruns)); } else { final CharBuff... |
@Test public void RunContainerArg_ArrayANDNOT3() { ArrayContainer ac = new ArrayContainer(1, new char[]{5}); Container rc = new RunContainer(new char[]{3, 10}, 1); assertEquals(new ArrayContainer(), ac.andNot(rc)); } | @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { ArrayContainer ac = new ArrayContainer(card); ac.card... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... |
@Test public void singleContainerOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(0).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withArrayAt(0).build().toMutableRoaringBitmap(); assertEquals... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void twoContainerOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withArrayAt(1).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(1).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withArrayAt(1).build().toMutableRoaringBitmap(); ... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void disjointOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withArrayAt(2).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(1).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withArrayAt(3).build().toMutableRoaringBitmap(); asse... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void disjointBigKeysOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withArrayAt(2).withBitmapAt((1 << 15) | 1).build() .toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(1).withRunAt((1 << 15) | 2).build() .toMutableRoaringBitmap(); ImmutableRoaringBitmap three = te... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void wideOr() { ImmutableRoaringBitmap[] input = IntStream.range(0, 20) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), BufferParallelAggregation.or(input)); } | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOr1() { ImmutableRoaringBitmap[] input = IntStream.range(0, 513) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), BufferParallelAggregation.or(input)); } | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOr2() { ImmutableRoaringBitmap[] input = IntStream.range(0, 1999) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), BufferParallelAggregation.or(input)); } | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOr3() { ImmutableRoaringBitmap[] input = IntStream.range(0, 4096) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), BufferParallelAggregation.or(input)); } | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOrNoParallelismAvailable1() { ImmutableRoaringBitmap[] input = IntStream.range(0, 513) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), NO_PARALLELISM_AVAIL... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOrNoParallelismAvailable2() { ImmutableRoaringBitmap[] input = IntStream.range(0, 2000) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), NO_PARALLELISM_AVAI... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void RunContainerArg_ArrayOR() { boolean atLeastOneArray = false; ArrayList<RunContainer> set = new ArrayList<RunContainer>(); ArrayList<Container> setb = new ArrayList<Container>(); getSetOfRunContainers(set, setb); for (int k = 0; k < set.size(); ++k) { for (int l = 0; l < set.size(); ++l) { assertEquals... | @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } } | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, in... | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, in... | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, in... |
@Test public void hugeOrNoParallelismAvailable3() { ImmutableRoaringBitmap[] input = IntStream.range(0, 4096) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), NO_PARALLELISM_AVAI... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOrInFJP1() { ImmutableRoaringBitmap[] input = IntStream.range(0, 513) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), POOL.submit(() -> BufferParallelAggre... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOrInFJP2() { ImmutableRoaringBitmap[] input = IntStream.range(0, 2000) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), POOL.submit(() -> BufferParallelAggr... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void hugeOrInFJP3() { ImmutableRoaringBitmap[] input = IntStream.range(0, 4096) .mapToObj(i -> testCase().withBitmapAt(0).withArrayAt(1).withRunAt(2).build().toMutableRoaringBitmap()) .toArray(ImmutableRoaringBitmap[]::new); assertEquals(BufferFastAggregation.or(input), POOL.submit(() -> BufferParallelAggr... | public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>> slices = new ArrayList<>(g... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... | BufferParallelAggregation { public static MutableRoaringBitmap or(ImmutableRoaringBitmap... bitmaps) { SortedMap<Character, List<MappeableContainer>> grouped = groupByKey(bitmaps); char[] keys = new char[grouped.size()]; MappeableContainer[] values = new MappeableContainer[grouped.size()]; List<List<MappeableContainer>... |
@Test public void singleContainerXOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(0).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withArrayAt(0).build().toMutableRoaringBitmap(); assertEqual... | public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... |
@Test public void missingMiddleContainerXOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withBitmapAt(1).withArrayAt(2).build() .toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(0).withArrayAt(2).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withAr... | public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... |
@Test public void twoContainerXOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withArrayAt(1).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(1).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withArrayAt(1).build().toMutableRoaringBitmap();... | public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... |
@Test public void disjointXOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withArrayAt(2).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(1).build().toMutableRoaringBitmap(); ImmutableRoaringBitmap three = testCase().withArrayAt(3).build().toMutableRoaringBitmap(); ass... | public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... |
@Test public void disjointBigKeysXOR() { ImmutableRoaringBitmap one = testCase().withRunAt(0).withArrayAt(2).withBitmapAt((1 << 15) | 1).build() .toMutableRoaringBitmap(); ImmutableRoaringBitmap two = testCase().withBitmapAt(1).withRunAt((1 << 15) | 2).build() .toMutableRoaringBitmap(); ImmutableRoaringBitmap three = t... | public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } } | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... | BufferParallelAggregation { public static MutableRoaringBitmap xor(ImmutableRoaringBitmap... bitmaps) { return groupByKey(bitmaps) .entrySet() .parallelStream() .collect(XOR); } static SortedMap<Character, List<MappeableContainer>> groupByKey(
ImmutableRoaringBitmap... bitmaps); static MutableRoaringBitmap o... |
@Test public void addInvalidRange() { assertThrows(IllegalArgumentException.class, () -> { MappeableContainer ac = new MappeableArrayContainer(); ac.add(13, 1); }); } | @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (char) begin); if (in... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... |
@Test public void RunContainerArg_ArrayXOR() { boolean atLeastOneArray = false; ArrayList<RunContainer> set = new ArrayList<RunContainer>(); ArrayList<Container> setb = new ArrayList<Container>(); getSetOfRunContainers(set, setb); for (int k = 0; k < set.size(); ++k) { for (int l = 0; l < set.size(); ++l) { assertEqual... | @Override public Container xor(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyxor(x).repairAfterLazy(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { return x.xor(this.getCharIterator()); } return toBitmapOrArrayCo... | RunContainer extends Container implements Cloneable { @Override public Container xor(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyxor(x).repairAfterLazy(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { return x.x... | RunContainer extends Container implements Cloneable { @Override public Container xor(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyxor(x).repairAfterLazy(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { return x.x... | RunContainer extends Container implements Cloneable { @Override public Container xor(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyxor(x).repairAfterLazy(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { return x.x... | RunContainer extends Container implements Cloneable { @Override public Container xor(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyxor(x).repairAfterLazy(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { return x.x... |
@Test public void iaddInvalidRange() { assertThrows(IllegalArgumentException.class, () -> { MappeableContainer ac = new MappeableArrayContainer(); ac.iadd(13, 1); }); } | @Override public MappeableContainer iadd(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (char) begin); if (inde... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iadd(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buffer... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iadd(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buffer... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iadd(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buffer... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iadd(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buffer... |
@Test public void remove() { MappeableContainer ac = new MappeableArrayContainer(); ac = ac.iadd(1,3); ac = ac.remove((char) 2); assertEquals(1, ac.getCardinality()); assertTrue(ac.contains((char) 1)); } | @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (char) begin); if ... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... |
@Test public void removeInvalidRange() { assertThrows(IllegalArgumentException.class, () -> { MappeableContainer ac = new MappeableArrayContainer(); ac.remove(13, 1); }); } | @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (char) begin); if ... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer remove(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = B... |
@Test public void iremoveInvalidRange() { assertThrows(IllegalArgumentException.class, () -> { MappeableContainer ac = new MappeableArrayContainer(); ac.iremove(13, 1); }); } | @Override public MappeableContainer iremove(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (char) begin); if (i... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iremove(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buf... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iremove(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buf... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iremove(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buf... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer iremove(int begin, int end) { if (end == begin) { return this; } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buf... |
@Test public void add() { MappeableContainer ac = newArrayContainer(1, 2, 3, 5); ac = ac.add((char) 4); assertEquals(5, ac.getCardinality()); for (int i = 1; i <= 5; i++) { assertTrue(ac.contains((char) i)); } } | @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (char) begin); if (in... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer add(int begin, int end) { if (end == begin) { return clone(); } if ((begin > end) || (end > (1 << 16))) { throw new IllegalArgumentException("Invalid range [" + begin + "," + end + ")"); } int indexstart = Buff... |
@Test public void flip() { MappeableContainer ac = newArrayContainer(1, 2, 3, 5); ac = ac.flip((char) 4); assertEquals(5, ac.getCardinality()); for (int i = 1; i <= 5; i++) { assertTrue(ac.contains((char) i)); } } | @Override public MappeableContainer flip(char x) { if (BufferUtil.isBackedBySimpleArray(this.content)) { char[] sarray = content.array(); int loc = Util.unsignedBinarySearch(sarray, 0, cardinality, x); if (loc < 0) { if (cardinality >= DEFAULT_MAX_SIZE) { MappeableBitmapContainer a = this.toBitmapContainer(); a.add(x);... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer flip(char x) { if (BufferUtil.isBackedBySimpleArray(this.content)) { char[] sarray = content.array(); int loc = Util.unsignedBinarySearch(sarray, 0, cardinality, x); if (loc < 0) { if (cardinality >= DEFAULT_MA... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer flip(char x) { if (BufferUtil.isBackedBySimpleArray(this.content)) { char[] sarray = content.array(); int loc = Util.unsignedBinarySearch(sarray, 0, cardinality, x); if (loc < 0) { if (cardinality >= DEFAULT_MA... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer flip(char x) { if (BufferUtil.isBackedBySimpleArray(this.content)) { char[] sarray = content.array(); int loc = Util.unsignedBinarySearch(sarray, 0, cardinality, x); if (loc < 0) { if (cardinality >= DEFAULT_MA... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableContainer flip(char x) { if (BufferUtil.isBackedBySimpleArray(this.content)) { char[] sarray = content.array(); int loc = Util.unsignedBinarySearch(sarray, 0, cardinality, x); if (loc < 0) { if (cardinality >= DEFAULT_MA... |
@Test public void iand() { MappeableContainer ac = new MappeableArrayContainer(); ac = ac.add(10,20); MappeableContainer bc = new MappeableBitmapContainer(); bc = bc.add(15,25); ac.iand(bc); assertEquals(5, ac.getCardinality()); for (int i = 15; i < 20; i++) { assertTrue(ac.contains((char) i)); } } | @Override public MappeableArrayContainer iand(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; if (!BufferUtil.isBackedBySimpleArray(value1.content)) { throw new RuntimeException("Should not happen. Internal bug."); } value1.cardinality = BufferUtil.unsignedIntersect2by2(value1.conte... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableArrayContainer iand(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; if (!BufferUtil.isBackedBySimpleArray(value1.content)) { throw new RuntimeException("Should not happen. Internal bu... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableArrayContainer iand(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; if (!BufferUtil.isBackedBySimpleArray(value1.content)) { throw new RuntimeException("Should not happen. Internal bu... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableArrayContainer iand(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; if (!BufferUtil.isBackedBySimpleArray(value1.content)) { throw new RuntimeException("Should not happen. Internal bu... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public MappeableArrayContainer iand(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; if (!BufferUtil.isBackedBySimpleArray(value1.content)) { throw new RuntimeException("Should not happen. Internal bu... |
@Test public void intersects() { MappeableContainer ac1 = new MappeableArrayContainer(); ac1 = ac1.add(10,20); MappeableContainer ac2 = new MappeableArrayContainer(); ac2 = ac2.add(15,25); assertTrue(ac1.intersects(ac2)); } | @Override public boolean intersects(MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; return BufferUtil.unsignedIntersects(value1.content, value1.getCardinality(), value2.content, value2.getCardinality()); } | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public boolean intersects(MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; return BufferUtil.unsignedIntersects(value1.content, value1.getCardinality(), value2.content, value2.getCardinality()); } } | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public boolean intersects(MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; return BufferUtil.unsignedIntersects(value1.content, value1.getCardinality(), value2.content, value2.getCardinality()); } MappeableArrayC... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public boolean intersects(MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; return BufferUtil.unsignedIntersects(value1.content, value1.getCardinality(), value2.content, value2.getCardinality()); } MappeableArrayC... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public boolean intersects(MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; return BufferUtil.unsignedIntersects(value1.content, value1.getCardinality(), value2.content, value2.getCardinality()); } MappeableArrayC... |
@Test public void numberOfRuns() { MappeableContainer ac = newArrayContainer(1, 13); assertEquals(1, ac.numberOfRuns()); } | @Override int numberOfRuns() { if (cardinality == 0) { return 0; } if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); int numRuns = 1; int oldv = (c[0]); for (int i = 1; i < cardinality; i++) { int newv = (c[i]); if (oldv + 1 != newv) { ++numRuns; } oldv = newv; } return numRuns; } else { int ... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override int numberOfRuns() { if (cardinality == 0) { return 0; } if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); int numRuns = 1; int oldv = (c[0]); for (int i = 1; i < cardinality; i++) { int newv = (c[i]); if (old... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override int numberOfRuns() { if (cardinality == 0) { return 0; } if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); int numRuns = 1; int oldv = (c[0]); for (int i = 1; i < cardinality; i++) { int newv = (c[i]); if (old... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override int numberOfRuns() { if (cardinality == 0) { return 0; } if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); int numRuns = 1; int oldv = (c[0]); for (int i = 1; i < cardinality; i++) { int newv = (c[i]); if (old... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override int numberOfRuns() { if (cardinality == 0) { return 0; } if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); int numRuns = 1; int oldv = (c[0]); for (int i = 1; i < cardinality; i++) { int newv = (c[i]); if (old... |
@Test public void foreach() { MappeableContainer ac = newArrayContainer(0, 64); ac.forEach((char) 0, new IntConsumer() { int expected = 0; @Override public void accept(int value) { assertEquals(value, expected++); } }); } | @Override public void forEach(char msb, IntConsumer ic) { int high = ((int) msb) << 16; if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); for (int k = 0; k < cardinality; ++k) { ic.accept((c[k] & 0xFFFF) | high); } } else { for (int k = 0; k < cardinality; ++k) { ic.accept((content.get(k) & 0... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public void forEach(char msb, IntConsumer ic) { int high = ((int) msb) << 16; if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); for (int k = 0; k < cardinality; ++k) { ic.accept((c[k] & 0xFFFF) | high); } } el... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public void forEach(char msb, IntConsumer ic) { int high = ((int) msb) << 16; if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); for (int k = 0; k < cardinality; ++k) { ic.accept((c[k] & 0xFFFF) | high); } } el... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public void forEach(char msb, IntConsumer ic) { int high = ((int) msb) << 16; if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); for (int k = 0; k < cardinality; ++k) { ic.accept((c[k] & 0xFFFF) | high); } } el... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public void forEach(char msb, IntConsumer ic) { int high = ((int) msb) << 16; if (BufferUtil.isBackedBySimpleArray(content)) { char[] c = content.array(); for (int k = 0; k < cardinality; ++k) { ic.accept((c[k] & 0xFFFF) | high); } } el... |
@Test public void RunContainerFromBitmap() { Container rc = new RunContainer(); Container bc = new BitmapContainer(); rc = rc.add((char) 2); bc = bc.add((char) 2); rc = rc.add((char) 3); bc = bc.add((char) 3); rc = rc.add((char) 4); bc = bc.add((char) 4); rc = rc.add((char) 17); bc = bc.add((char) 17); for (int i = 192... | @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... |
@Test public void testToString() { MappeableArrayContainer ac1 = new MappeableArrayContainer(5, 15); ac1.add((char) -3); ac1.add((char) -17); assertEquals("{5,6,7,8,9,10,11,12,13,14,65519,65533}", ac1.toString()); } | @Override public String toString() { if (this.cardinality == 0) { return "{}"; } final StringBuilder sb = new StringBuilder(); sb.append("{"); for (int i = 0; i < this.cardinality - 1; i++) { sb.append((int)(this.content.get(i))); sb.append(","); } sb.append((int)(this.content.get(this.cardinality - 1))); sb.append("}"... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public String toString() { if (this.cardinality == 0) { return "{}"; } final StringBuilder sb = new StringBuilder(); sb.append("{"); for (int i = 0; i < this.cardinality - 1; i++) { sb.append((int)(this.content.get(i))); sb.append(",");... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public String toString() { if (this.cardinality == 0) { return "{}"; } final StringBuilder sb = new StringBuilder(); sb.append("{"); for (int i = 0; i < this.cardinality - 1; i++) { sb.append((int)(this.content.get(i))); sb.append(",");... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public String toString() { if (this.cardinality == 0) { return "{}"; } final StringBuilder sb = new StringBuilder(); sb.append("{"); for (int i = 0; i < this.cardinality - 1; i++) { sb.append((int)(this.content.get(i))); sb.append(",");... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public String toString() { if (this.cardinality == 0) { return "{}"; } final StringBuilder sb = new StringBuilder(); sb.append("{"); for (int i = 0; i < this.cardinality - 1; i++) { sb.append((int)(this.content.get(i))); sb.append(",");... |
@Test public void testNextValue() { MappeableArrayContainer container = new MappeableArrayContainer(CharBuffer.wrap(new char[] { 10, 20, 30}), 3); assertEquals(10, container.nextValue((char)10)); assertEquals(20, container.nextValue((char)11)); assertEquals(30, container.nextValue((char)30)); } | @Override public int nextValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index == cardinality) { return fromValue == content.get(cardinality - 1) ? (fromValue) : -1; } return (content.get(index)); } | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index == cardinality) { return fromValue == content.get(cardinality - 1) ? (fromValue) : -1; } return (content.get(inde... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index == cardinality) { return fromValue == content.get(cardinality - 1) ? (fromValue) : -1; } return (content.get(inde... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index == cardinality) { return fromValue == content.get(cardinality - 1) ? (fromValue) : -1; } return (content.get(inde... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index == cardinality) { return fromValue == content.get(cardinality - 1) ? (fromValue) : -1; } return (content.get(inde... |
@Test public void testPreviousAbsentValueEmpty() { MappeableArrayContainer container = new MappeableArrayContainer(); for (int i = 0; i < 1000; i++) { assertEquals(i, container.previousAbsentValue((char)i)); } } | @Override public int previousAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == 0) { return fromValue == content.get(0) ? fromValue - 1 : fromValue; } if (content.get(index) != fromValue) { return fromValue... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int previousAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == 0) { return fromValue == content.get(0) ? fromValue ... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int previousAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == 0) { return fromValue == content.get(0) ? fromValue ... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int previousAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == 0) { return fromValue == content.get(0) ? fromValue ... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int previousAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == 0) { return fromValue == content.get(0) ? fromValue ... |
@Test public void testNextAbsentValueEmpty() { MappeableArrayContainer container = new MappeableArrayContainer(); for (int i = 0; i < 1000; i++) { assertEquals(i, container.nextAbsentValue((char)i)); } } | @Override public int nextAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == cardinality - 1) { return fromValue == content.get(cardinality - 1) ? fromValue + 1 : fromValue; } if (content.get(index) != fromV... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == cardinality - 1) { return fromValue == content.get(cardi... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == cardinality - 1) { return fromValue == content.get(cardi... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == cardinality - 1) { return fromValue == content.get(cardi... | MappeableArrayContainer extends MappeableContainer implements Cloneable { @Override public int nextAbsentValue(char fromValue) { int index = BufferUtil.advanceUntil(content, -1, cardinality, fromValue); if (index >= cardinality) { return fromValue; } if (index == cardinality - 1) { return fromValue == content.get(cardi... |
@Test public void resizeOnlyIfNecessary() { char[] keys = new char[1]; int size = 0; MappeableContainer[] values = new MappeableContainer[1]; MutableRoaringArray array = new MutableRoaringArray(keys, values, size); array.extendArray(1); assertSame(keys, array.keys, "Keys were not reallocated"); } | protected void extendArray(int k) { if (this.size + k > this.keys.length) { int newCapacity; if (this.keys.length < 1024) { newCapacity = 2 * (this.size + k); } else { newCapacity = 5 * (this.size + k) / 4; } this.keys = Arrays.copyOf(this.keys, newCapacity); this.values = Arrays.copyOf(this.values, newCapacity); } } | MutableRoaringArray implements Cloneable, Externalizable, PointableRoaringArray,
AppendableStorage<MappeableContainer> { protected void extendArray(int k) { if (this.size + k > this.keys.length) { int newCapacity; if (this.keys.length < 1024) { newCapacity = 2 * (this.size + k); } else { newCapacity = 5 * (this... | MutableRoaringArray implements Cloneable, Externalizable, PointableRoaringArray,
AppendableStorage<MappeableContainer> { protected void extendArray(int k) { if (this.size + k > this.keys.length) { int newCapacity; if (this.keys.length < 1024) { newCapacity = 2 * (this.size + k); } else { newCapacity = 5 * (this... | MutableRoaringArray implements Cloneable, Externalizable, PointableRoaringArray,
AppendableStorage<MappeableContainer> { protected void extendArray(int k) { if (this.size + k > this.keys.length) { int newCapacity; if (this.keys.length < 1024) { newCapacity = 2 * (this.size + k); } else { newCapacity = 5 * (this... | MutableRoaringArray implements Cloneable, Externalizable, PointableRoaringArray,
AppendableStorage<MappeableContainer> { protected void extendArray(int k) { if (this.size + k > this.keys.length) { int newCapacity; if (this.keys.length < 1024) { newCapacity = 2 * (this.size + k); } else { newCapacity = 5 * (this... |
@Test public void ANDNOTtest() { final MutableRoaringBitmap rr = new MutableRoaringBitmap(); for (int k = 4000; k < 4256; ++k) { rr.add(k); } for (int k = 65536; k < 65536 + 4000; ++k) { rr.add(k); } for (int k = 3 * 65536; k < 3 * 65536 + 9000; ++k) { rr.add(k); } for (int k = 4 * 65535; k < 4 * 65535 + 7000; ++k) { r... | public static MutableRoaringBitmap andNot(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2, long rangeStart, long rangeEnd) { rangeSanityCheck(rangeStart,rangeEnd); MutableRoaringBitmap rb1 = selectRangeWithoutCopy(x1, rangeStart, rangeEnd); MutableRoaringBitmap rb2 = selectRangeWithoutCopy(x2, rangeSta... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap andNot(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2, long rangeStart, long rangeEnd) { rangeSanityCheck(rangeStart,rangeEnd); MutableRoaringBitmap rb1 = selectRangeWithout... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap andNot(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2, long rangeStart, long rangeEnd) { rangeSanityCheck(rangeStart,rangeEnd); MutableRoaringBitmap rb1 = selectRangeWithout... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap andNot(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2, long rangeStart, long rangeEnd) { rangeSanityCheck(rangeStart,rangeEnd); MutableRoaringBitmap rb1 = selectRangeWithout... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap andNot(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2, long rangeStart, long rangeEnd) { rangeSanityCheck(rangeStart,rangeEnd); MutableRoaringBitmap rb1 = selectRangeWithout... |
@Test public void fliptest1() { final MutableRoaringBitmap rb = new MutableRoaringBitmap(); rb.add(0); rb.add(2); final MutableRoaringBitmap rb2 = MutableRoaringBitmap.flip(rb, 0L, 3); final MutableRoaringBitmap result = new MutableRoaringBitmap(); result.add(1); assertEquals(result, rb2); } | public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range " + rangeStart + " -- " + rangeEnd); } MutableRoaringBitmap answer = new MutableRoaringBitmap()... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... |
@Test public void fliptest2() { final MutableRoaringBitmap rb = new MutableRoaringBitmap(); rb.add(0); rb.add(2); final MutableRoaringBitmap rb2 = ImmutableRoaringBitmap.flip(rb, 0L, 3); final MutableRoaringBitmap result = new MutableRoaringBitmap(); result.add(1); assertEquals(result, rb2); } | public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range " + rangeStart + " -- " + rangeEnd); } MutableRoaringBitmap answer = new MutableRoaringBitmap()... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static MutableRoaringBitmap flip(ImmutableRoaringBitmap bm, final long rangeStart, final long rangeEnd) { rangeSanityCheck(rangeStart, rangeEnd); if (rangeStart >= rangeEnd) { throw new RuntimeException("Invalid range "... |
@Test public void testContains() throws IOException { System.out.println("test contains"); MutableRoaringBitmap mr = new MutableRoaringBitmap(); for (int k = 0; k < 1000; ++k) { mr.add(17 * k); } ByteBuffer buffer = serializeRoaring(mr); buffer.rewind(); ImmutableRoaringBitmap ir = new ImmutableRoaringBitmap(buffer); f... | @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... |
@Test public void testContainsA() throws IOException { System.out.println("test contains (runs too)"); MutableRoaringBitmap mr = new MutableRoaringBitmap(); for (int k = 0; k < 1000; ++k) { mr.add(17 * k); } for (int k = 200000; k < 210000; ++k) { if (k % 19 != 0) { mr.add(k); } } mr.runOptimize(); ByteBuffer buffer = ... | @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... |
@Test public void RunContainerFromBitmap1() { Container rc = new RunContainer(); Container bc = new BitmapContainer(); rc = rc.add((char) 2); bc = bc.add((char) 2); rc = rc.add((char) 3); bc = bc.add((char) 3); rc = rc.add((char) 4); bc = bc.add((char) 4); rc = rc.add((char) 17); bc = bc.add((char) 17); for (int i = 19... | @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... |
@Test public void testPartialRadixSortEmpty() { int[] data = new int[] {}; int[] test = Arrays.copyOf(data, data.length); Util.partialRadixSort(test); assertArrayEquals(data, test); } | public static void partialRadixSort(int[] data) { final int radix = 8; int shift = 16; int mask = 0xFF0000; int[] copy = new int[data.length]; int[] histogram = new int[(1 << radix) + 1]; while (shift < 32) { for (int i = 0; i < data.length; ++i) { ++histogram[((data[i] & mask) >>> shift) + 1]; } for (int i = 0; i < 1 ... | Util { public static void partialRadixSort(int[] data) { final int radix = 8; int shift = 16; int mask = 0xFF0000; int[] copy = new int[data.length]; int[] histogram = new int[(1 << radix) + 1]; while (shift < 32) { for (int i = 0; i < data.length; ++i) { ++histogram[((data[i] & mask) >>> shift) + 1]; } for (int i = 0;... | Util { public static void partialRadixSort(int[] data) { final int radix = 8; int shift = 16; int mask = 0xFF0000; int[] copy = new int[data.length]; int[] histogram = new int[(1 << radix) + 1]; while (shift < 32) { for (int i = 0; i < data.length; ++i) { ++histogram[((data[i] & mask) >>> shift) + 1]; } for (int i = 0;... | Util { public static void partialRadixSort(int[] data) { final int radix = 8; int shift = 16; int mask = 0xFF0000; int[] copy = new int[data.length]; int[] histogram = new int[(1 << radix) + 1]; while (shift < 32) { for (int i = 0; i < data.length; ++i) { ++histogram[((data[i] & mask) >>> shift) + 1]; } for (int i = 0;... | Util { public static void partialRadixSort(int[] data) { final int radix = 8; int shift = 16; int mask = 0xFF0000; int[] copy = new int[data.length]; int[] histogram = new int[(1 << radix) + 1]; while (shift < 32) { for (int i = 0; i < data.length; ++i) { ++histogram[((data[i] & mask) >>> shift) + 1]; } for (int i = 0;... |
@Test public void testSerializeImmutable() throws IOException { MutableRoaringBitmap mr = new MutableRoaringBitmap(); mr.add(5); ByteBuffer buffer = serializeRoaring(mr); buffer.rewind(); buffer = serializeRoaring(new ImmutableRoaringBitmap(buffer)); buffer.rewind(); ImmutableRoaringBitmap ir = new ImmutableRoaringBitm... | @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... |
@Test public void testSerializeImmutableA() throws IOException { MutableRoaringBitmap mr = new MutableRoaringBitmap(); for (int i = 1024 * 1024 - 20; i < 1024 * 1024 + 20; ++i) { mr.add(i); } mr.runOptimize(); ByteBuffer buffer = serializeRoaring(mr); buffer.rewind(); buffer = serializeRoaring(new ImmutableRoaringBitma... | @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public boolean contains(final int x) { final char hb = highbits(x); int index = highLowContainer.getContainerIndex(hb); return index >= 0 && highLowContainer.containsForContainerAtIndex(index, lowbits(x)); } protecte... |
@Test public void testEmptyFirst() { assertThrows(NoSuchElementException.class, () -> new MutableRoaringBitmap().toImmutableRoaringBitmap().first()); } | @Override public int first() { return highLowContainer.first(); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int first() { return highLowContainer.first(); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int first() { return highLowContainer.first(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int first() { return highLowContainer.first(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); static MutableRoaringBitmap and(final Iterator<? extends ImmutableRoaringBitma... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int first() { return highLowContainer.first(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); static MutableRoaringBitmap and(final Iterator<? extends ImmutableRoaringBitma... |
@Test public void testEmptyLast() { assertThrows(NoSuchElementException.class, () -> new MutableRoaringBitmap().toImmutableRoaringBitmap().last()); } | @Override public int last() { return highLowContainer.last(); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); static MutableRoaringBitmap and(final Iterator<? extends ImmutableRoaringBitmap>... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); static MutableRoaringBitmap and(final Iterator<? extends ImmutableRoaringBitmap>... |
@Test public void testAndNotCardinality() { final MutableRoaringBitmap rb = new MutableRoaringBitmap(); for (int k = 0; k < 4000; ++k) { rb.add(k); } rb.add(100000); rb.add(110000); rb.add(1L << 20, 1L << 21); rb.flip((1 << 20) | (1 << 19)); final MutableRoaringBitmap rb2 = new MutableRoaringBitmap(); for (int k = 0; k... | public static int andNotCardinality(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2) { return x1.getCardinality() - andCardinality(x1, x2); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static int andNotCardinality(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2) { return x1.getCardinality() - andCardinality(x1, x2); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static int andNotCardinality(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2) { return x1.getCardinality() - andCardinality(x1, x2); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static int andNotCardinality(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2) { return x1.getCardinality() - andCardinality(x1, x2); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { public static int andNotCardinality(final ImmutableRoaringBitmap x1, final ImmutableRoaringBitmap x2) { return x1.getCardinality() - andCardinality(x1, x2); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ... |
@Test public void testNegativeAdd() { MutableRoaringBitmap bitmap = new MutableRoaringBitmap(); bitmap.add(-7); assertEquals("{4294967289}", bitmap.toString()); } | @Override public String toString() { final StringBuilder answer = new StringBuilder(); final IntIterator i = this.getIntIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next() & 0xFFFFFFFFL); } while (i.hasNext()) { answer.append(","); if(answer.length() > 0x80000) { answer.append("..."); break; } ans... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final IntIterator i = this.getIntIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next() & 0xFFFFFFFFL); } while (i.hasNe... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final IntIterator i = this.getIntIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next() & 0xFFFFFFFFL); } while (i.hasNe... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final IntIterator i = this.getIntIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next() & 0xFFFFFFFFL); } while (i.hasNe... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final IntIterator i = this.getIntIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next() & 0xFFFFFFFFL); } while (i.hasNe... |
@Test public void testNegative_last() { MutableRoaringBitmap bitmap = new MutableRoaringBitmap(); bitmap.add(-7); bitmap.add(777); assertEquals(-7, bitmap.last()); } | @Override public int last() { return highLowContainer.last(); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); } | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); static MutableRoaringBitmap and(final Iterator<? extends ImmutableRoaringBitmap>... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public int last() { return highLowContainer.last(); } protected ImmutableRoaringBitmap(); ImmutableRoaringBitmap(final ByteBuffer b); static MutableRoaringBitmap and(final Iterator<? extends ImmutableRoaringBitmap>... |
@Test public void testNextValue() { ImmutableRoaringBitmap bitmap = SeededTestData.TestDataSet.testCase() .withRunAt(0) .withBitmapAt(1) .withArrayAt(2) .withRunAt(3) .withBitmapAt(4) .withArrayAt(5) .build() .toMutableRoaringBitmap(); BitSet bitset = new BitSet(); bitmap.forEach((IntConsumer) bitset::set); long b1 = 0... | @Override public long nextValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); long nextSetBit = -1L; while (containerIndex < highLowContainer.size() && nextSetBit == -1L) { char containerKey = highLowContainer.getKeyAtIndex(containerIndex); MappeableContai... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long nextValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); long nextSetBit = -1L; while (containerIndex < highLowContainer.size() && nextSetBit... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long nextValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); long nextSetBit = -1L; while (containerIndex < highLowContainer.size() && nextSetBit... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long nextValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); long nextSetBit = -1L; while (containerIndex < highLowContainer.size() && nextSetBit... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long nextValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); long nextSetBit = -1L; while (containerIndex < highLowContainer.size() && nextSetBit... |
@Test public void testPreviousValue() { MutableRoaringBitmap bitmap = SeededTestData.TestDataSet.testCase() .withRunAt(0) .withBitmapAt(1) .withArrayAt(2) .withRunAt(3) .withBitmapAt(4) .withArrayAt(5) .build().toMutableRoaringBitmap(); BitSet bitset = new BitSet(); bitmap.forEach((IntConsumer) bitset::set); long b1 = ... | @Override public long previousValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); if (containerIndex == highLowContainer.size()) { return last(); } long prevSetBit = -1L; while (containerIndex != -1 && containerIndex < highLowContainer.size() && prevSetBit... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long previousValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); if (containerIndex == highLowContainer.size()) { return last(); } long prevSetBi... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long previousValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); if (containerIndex == highLowContainer.size()) { return last(); } long prevSetBi... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long previousValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); if (containerIndex == highLowContainer.size()) { return last(); } long prevSetBi... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long previousValue(int fromValue) { char key = highbits(fromValue); int containerIndex = highLowContainer.advanceUntil(key, -1); if (containerIndex == highLowContainer.size()) { return last(); } long prevSetBi... |
@Test public void testRangeCardinalityAtBoundary() { MutableRoaringBitmap r = new MutableRoaringBitmap(); r.add(66236); assertEquals(1, r.rangeCardinality(60000, 70000)); } | @Override public long rangeCardinality(long start, long end) { if(Long.compareUnsigned(start, end) >= 0) { return 0; } long size = 0; int startIndex = this.highLowContainer.getIndex(highbits(start)); if(startIndex < 0) { startIndex = -startIndex - 1; } else { int inContainerStart = (lowbits(start)); if(inContainerStart... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long rangeCardinality(long start, long end) { if(Long.compareUnsigned(start, end) >= 0) { return 0; } long size = 0; int startIndex = this.highLowContainer.getIndex(highbits(start)); if(startIndex < 0) { start... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long rangeCardinality(long start, long end) { if(Long.compareUnsigned(start, end) >= 0) { return 0; } long size = 0; int startIndex = this.highLowContainer.getIndex(highbits(start)); if(startIndex < 0) { start... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long rangeCardinality(long start, long end) { if(Long.compareUnsigned(start, end) >= 0) { return 0; } long size = 0; int startIndex = this.highLowContainer.getIndex(highbits(start)); if(startIndex < 0) { start... | ImmutableRoaringBitmap implements Iterable<Integer>, Cloneable, ImmutableBitmapDataProvider { @Override public long rangeCardinality(long start, long end) { if(Long.compareUnsigned(start, end) >= 0) { return 0; } long size = 0; int startIndex = this.highLowContainer.getIndex(highbits(start)); if(startIndex < 0) { start... |
@Test public void RunContainerFromBitmap2() { Container rc = new RunContainer(); Container bc = new BitmapContainer(); rc = rc.add((char) 2); bc = bc.add((char) 2); rc = rc.add((char) 3); bc = bc.add((char) 3); rc = rc.add((char) 4); bc = bc.add((char) 4); rc = rc.add((char) 17); bc = bc.add((char) 17); for (int i = 19... | @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... |
@Test public void testAddInt() { Roaring64Bitmap map = newDefaultCtor(); map.addInt(-1); assertEquals(-1, map.select(0)); } | public void addInt(int x) { addLong(x); } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(x); } } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(x); } Roaring64Bitmap(); } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(x); } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override voi... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(x); } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); Iterator<Long> iterator(); @Override voi... |
@Test public void testIterator_NextWithoutHasNext_Empty() { assertThrows(IllegalStateException.class, () -> { Roaring64Bitmap map = newDefaultCtor(); map.getLongIterator().next(); }); } | @Override public LongIterator getLongIterator() { LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); return toIterator(leafNodeIterator, false); } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); return toIterator(leafNodeIterator, false); } } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); return toIterator(leafNodeIterator, false); } Roaring64Bitmap(); } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); return toIterator(leafNodeIterator, false); } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); ... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); return toIterator(leafNodeIterator, false); } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); ... |
@Test public void testSerializationEmpty() throws IOException, ClassNotFoundException { final Roaring64Bitmap map = newDefaultCtor(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { oos.writeObject(map); } final Roaring64Bitmap clone; try (ObjectIn... | @Override public long getLongCardinality() { if (highLowContainer.isEmpty()) { return 0L; } Iterator<Container> containerIterator = highLowContainer.containerIterator(); long cardinality = 0L; while (containerIterator.hasNext()) { Container container = containerIterator.next(); cardinality += container.getCardinality()... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (highLowContainer.isEmpty()) { return 0L; } Iterator<Container> containerIterator = highLowContainer.containerIterator(); long cardinality = 0L; while (containerIterator.hasNext()) { Container container =... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (highLowContainer.isEmpty()) { return 0L; } Iterator<Container> containerIterator = highLowContainer.containerIterator(); long cardinality = 0L; while (containerIterator.hasNext()) { Container container =... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (highLowContainer.isEmpty()) { return 0L; } Iterator<Container> containerIterator = highLowContainer.containerIterator(); long cardinality = 0L; while (containerIterator.hasNext()) { Container container =... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (highLowContainer.isEmpty()) { return 0L; } Iterator<Container> containerIterator = highLowContainer.containerIterator(); long cardinality = 0L; while (containerIterator.hasNext()) { Container container =... |
@Test public void testXor() { Roaring64Bitmap left = newDefaultCtor(); Roaring64Bitmap right = newDefaultCtor(); left.addLong(123); left.addLong(234); right.addLong(234); right.addLong(345); left.xor(right); assertEquals(2, left.getLongCardinality()); assertEquals(123, left.select(0)); assertEquals(345, left.select(1))... | public void xor(final Roaring64Bitmap x2) { KeyIterator keyIterator = x2.highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { byte[] high = keyIterator.next(); long containerIdx = keyIterator.currentContainerIdx(); Container container = x2.highLowContainer.getContainer(containerIdx); ContainerWithIndex c... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void xor(final Roaring64Bitmap x2) { KeyIterator keyIterator = x2.highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { byte[] high = keyIterator.next(); long containerIdx = keyIterator.currentContainerIdx(); Container container = ... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void xor(final Roaring64Bitmap x2) { KeyIterator keyIterator = x2.highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { byte[] high = keyIterator.next(); long containerIdx = keyIterator.currentContainerIdx(); Container container = ... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void xor(final Roaring64Bitmap x2) { KeyIterator keyIterator = x2.highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { byte[] high = keyIterator.next(); long containerIdx = keyIterator.currentContainerIdx(); Container container = ... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void xor(final Roaring64Bitmap x2) { KeyIterator keyIterator = x2.highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { byte[] high = keyIterator.next(); long containerIdx = keyIterator.currentContainerIdx(); Container container = ... |
@Test public void testAnd() { Roaring64Bitmap left = newDefaultCtor(); Roaring64Bitmap right = newDefaultCtor(); left.addLong(123); right.addLong(123); left.and(right); assertEquals(1, left.getLongCardinality()); assertEquals(123, left.select(0)); } | public void and(final Roaring64Bitmap x2) { KeyIterator thisIterator = highLowContainer.highKeyIterator(); while (thisIterator.hasNext()) { byte[] highKey = thisIterator.next(); long containerIdx = thisIterator.currentContainerIdx(); ContainerWithIndex containerWithIdx = x2.highLowContainer.searchContainer(highKey); if... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void and(final Roaring64Bitmap x2) { KeyIterator thisIterator = highLowContainer.highKeyIterator(); while (thisIterator.hasNext()) { byte[] highKey = thisIterator.next(); long containerIdx = thisIterator.currentContainerIdx(); ContainerWithIndex... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void and(final Roaring64Bitmap x2) { KeyIterator thisIterator = highLowContainer.highKeyIterator(); while (thisIterator.hasNext()) { byte[] highKey = thisIterator.next(); long containerIdx = thisIterator.currentContainerIdx(); ContainerWithIndex... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void and(final Roaring64Bitmap x2) { KeyIterator thisIterator = highLowContainer.highKeyIterator(); while (thisIterator.hasNext()) { byte[] highKey = thisIterator.next(); long containerIdx = thisIterator.currentContainerIdx(); ContainerWithIndex... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void and(final Roaring64Bitmap x2) { KeyIterator thisIterator = highLowContainer.highKeyIterator(); while (thisIterator.hasNext()) { byte[] highKey = thisIterator.next(); long containerIdx = thisIterator.currentContainerIdx(); ContainerWithIndex... |
@Test public void testAndNot() { Roaring64Bitmap left = newDefaultCtor(); Roaring64Bitmap right = newDefaultCtor(); left.addLong(123); right.addLong(234); left.andNot(right); assertEquals(1, left.getLongCardinality()); assertEquals(123, left.select(0)); } | public void andNot(final Roaring64Bitmap x2) { KeyIterator thisKeyIterator = highLowContainer.highKeyIterator(); while (thisKeyIterator.hasNext()) { byte[] high = thisKeyIterator.next(); long containerIdx = thisKeyIterator.currentContainerIdx(); ContainerWithIndex containerWithIdx2 = x2.highLowContainer.searchContainer... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void andNot(final Roaring64Bitmap x2) { KeyIterator thisKeyIterator = highLowContainer.highKeyIterator(); while (thisKeyIterator.hasNext()) { byte[] high = thisKeyIterator.next(); long containerIdx = thisKeyIterator.currentContainerIdx(); Contai... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void andNot(final Roaring64Bitmap x2) { KeyIterator thisKeyIterator = highLowContainer.highKeyIterator(); while (thisKeyIterator.hasNext()) { byte[] high = thisKeyIterator.next(); long containerIdx = thisKeyIterator.currentContainerIdx(); Contai... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void andNot(final Roaring64Bitmap x2) { KeyIterator thisKeyIterator = highLowContainer.highKeyIterator(); while (thisKeyIterator.hasNext()) { byte[] high = thisKeyIterator.next(); long containerIdx = thisKeyIterator.currentContainerIdx(); Contai... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void andNot(final Roaring64Bitmap x2) { KeyIterator thisKeyIterator = highLowContainer.highKeyIterator(); while (thisKeyIterator.hasNext()) { byte[] high = thisKeyIterator.next(); long containerIdx = thisKeyIterator.currentContainerIdx(); Contai... |
@Test public void testToString() { Roaring64Bitmap map = newDefaultCtor(); map.addLong(123); map.addLong(Long.MAX_VALUE); map.addLong(Long.MAX_VALUE + 1L); assertEquals("{123,9223372036854775807,-9223372036854775808}", map.toString()); } | @Override public String toString() { final StringBuilder answer = new StringBuilder(); final LongIterator i = this.getLongIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next()); } while (i.hasNext()) { answer.append(","); if (answer.length() > 0x80000) { answer.append("..."); break; } answer.append(... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final LongIterator i = this.getLongIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next()); } while (i.hasNext()) { answer.append(","); if (answer... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final LongIterator i = this.getLongIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next()); } while (i.hasNext()) { answer.append(","); if (answer... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final LongIterator i = this.getLongIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next()); } while (i.hasNext()) { answer.append(","); if (answer... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public String toString() { final StringBuilder answer = new StringBuilder(); final LongIterator i = this.getLongIterator(); answer.append("{"); if (i.hasNext()) { answer.append(i.next()); } while (i.hasNext()) { answer.append(","); if (answer... |
@Test public void testCardinalityAboveIntegerMaxValue_RoaringBitmap() { assertThrows(IllegalArgumentException.class, () -> { RoaringBitmap map = new RoaringBitmap(); map.add(0L, outOfRoaringBitmapRange); }); } | public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64Bitmap(); } | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); It... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64Bitmap(); void addInt(int x); @Override void addLong(long x); @Override long getLongCardinality(); int getIntCardinality(); @Override long select(final long j); It... |
@Test public void testTrim() { Roaring64Bitmap map = newDefaultCtor(); int enableTrim = 100; long from = RoaringIntPacking.pack(0, -1 - enableTrim); long to = from + 2 * enableTrim; assertNotEquals(RoaringIntPacking.high(to), RoaringIntPacking.high(from)); for (long i = from; i <= to; i++) { map.addLong(i); } map.trim(... | @Override public void trim() { if (highLowContainer.isEmpty()) { return; } KeyIterator keyIterator = highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { long containerIdx = keyIterator.currentContainerIdx(); Container container = highLowContainer.getContainer(containerIdx); if (container.isEmpty()) { ke... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { if (highLowContainer.isEmpty()) { return; } KeyIterator keyIterator = highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { long containerIdx = keyIterator.currentContainerIdx(); Container container = highLo... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { if (highLowContainer.isEmpty()) { return; } KeyIterator keyIterator = highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { long containerIdx = keyIterator.currentContainerIdx(); Container container = highLo... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { if (highLowContainer.isEmpty()) { return; } KeyIterator keyIterator = highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { long containerIdx = keyIterator.currentContainerIdx(); Container container = highLo... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { if (highLowContainer.isEmpty()) { return; } KeyIterator keyIterator = highLowContainer.highKeyIterator(); while (keyIterator.hasNext()) { long containerIdx = keyIterator.currentContainerIdx(); Container container = highLo... |
@Test public void testSelectEmpty() { assertThrows(IllegalArgumentException.class, () -> { Roaring64Bitmap map = newDefaultCtor(); map.select(0); }); } | @Override public long select(final long j) throws IllegalArgumentException { long left = j; LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); while (leafNodeIterator.hasNext()) { LeafNode leafNode = leafNodeIterator.next(); long containerIdx = leafNode.getContainerIdx(); Container con... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { long left = j; LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); while (leafNodeIterator.hasNext()) { LeafNode leafNode = leafNodeIterator.n... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { long left = j; LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); while (leafNodeIterator.hasNext()) { LeafNode leafNode = leafNodeIterator.n... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { long left = j; LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); while (leafNodeIterator.hasNext()) { LeafNode leafNode = leafNodeIterator.n... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { long left = j; LeafNodeIterator leafNodeIterator = highLowContainer.highKeyLeafNodeIterator(false); while (leafNodeIterator.hasNext()) { LeafNode leafNode = leafNodeIterator.n... |
@Test public void RunContainerFromBitmap3() { Container rc = new RunContainer(); Container bc = new BitmapContainer(); rc = rc.add((char) 2); bc = bc.add((char) 2); rc = rc.add((char) 3); bc = bc.add((char) 3); rc = rc.add((char) 4); bc = bc.add((char) 4); rc = rc.add((char) 17); bc = bc.add((char) 17); for (int i = 19... | @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } } | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... | RunContainer extends Container implements Cloneable { @Override public Container add(int begin, int end) { RunContainer rc = (RunContainer) clone(); return rc.iadd(begin, end); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected... |
@Test public void testRunOptimize() { Roaring64Bitmap map = new Roaring64Bitmap(); map.addLong(123); map.addLong(234); map.runOptimize(); } | public boolean runOptimize() { boolean hasChanged = false; ContainerIterator containerIterator = highLowContainer.containerIterator(); while (containerIterator.hasNext()) { Container container = containerIterator.next(); Container freshContainer = container.runOptimize(); if (freshContainer instanceof RunContainer) { h... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public boolean runOptimize() { boolean hasChanged = false; ContainerIterator containerIterator = highLowContainer.containerIterator(); while (containerIterator.hasNext()) { Container container = containerIterator.next(); Container freshContainer = cont... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public boolean runOptimize() { boolean hasChanged = false; ContainerIterator containerIterator = highLowContainer.containerIterator(); while (containerIterator.hasNext()) { Container container = containerIterator.next(); Container freshContainer = cont... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public boolean runOptimize() { boolean hasChanged = false; ContainerIterator containerIterator = highLowContainer.containerIterator(); while (containerIterator.hasNext()) { Container container = containerIterator.next(); Container freshContainer = cont... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public boolean runOptimize() { boolean hasChanged = false; ContainerIterator containerIterator = highLowContainer.containerIterator(); while (containerIterator.hasNext()) { Container container = containerIterator.next(); Container freshContainer = cont... |
@Test public void testFlip() { Roaring64Bitmap map = newDefaultCtor(); map.addLong(0); map.flip(0); assertFalse(map.contains(0)); assertTrue(map.getLongCardinality() == 0); } | public void flip(final long x) { byte[] high = LongUtils.highPart(x); ContainerWithIndex containerWithIndex = highLowContainer.searchContainer(high); if (containerWithIndex == null) { addLong(x); } else { char low = LongUtils.lowPart(x); Container freshOne = containerWithIndex.getContainer().flip(low); highLowContainer... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void flip(final long x) { byte[] high = LongUtils.highPart(x); ContainerWithIndex containerWithIndex = highLowContainer.searchContainer(high); if (containerWithIndex == null) { addLong(x); } else { char low = LongUtils.lowPart(x); Container fres... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void flip(final long x) { byte[] high = LongUtils.highPart(x); ContainerWithIndex containerWithIndex = highLowContainer.searchContainer(high); if (containerWithIndex == null) { addLong(x); } else { char low = LongUtils.lowPart(x); Container fres... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void flip(final long x) { byte[] high = LongUtils.highPart(x); ContainerWithIndex containerWithIndex = highLowContainer.searchContainer(high); if (containerWithIndex == null) { addLong(x); } else { char low = LongUtils.lowPart(x); Container fres... | Roaring64Bitmap implements Externalizable, LongBitmapDataProvider { public void flip(final long x) { byte[] high = LongUtils.highPart(x); ContainerWithIndex containerWithIndex = highLowContainer.searchContainer(high); if (containerWithIndex == null) { addLong(x); } else { char low = LongUtils.lowPart(x); Container fres... |
@Test public void testAddInt() { Roaring64NavigableMap map = newDefaultCtor(); map.addInt(-1); assertEquals(Util.toUnsignedLong(-1), map.select(0)); } | public void addInt(int x) { addLong(Util.toUnsignedLong(x)); } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(Util.toUnsignedLong(x)); } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(Util.toUnsignedLong(x)); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProvide... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(Util.toUnsignedLong(x)); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProvide... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void addInt(int x) { addLong(Util.toUnsignedLong(x)); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(BitmapDataProvide... |
@Test public void testIterator_NextWithoutHasNext_Empty() { assertThrows(IllegalStateException.class, () -> { Roaring64NavigableMap map = newDefaultCtor(); map.getLongIterator().next(); }); } | @Override public LongIterator getLongIterator() { final Iterator<Map.Entry<Integer, BitmapDataProvider>> it = highToBitmap.entrySet().iterator(); return toIterator(it, false); } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { final Iterator<Map.Entry<Integer, BitmapDataProvider>> it = highToBitmap.entrySet().iterator(); return toIterator(it, false); } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { final Iterator<Map.Entry<Integer, BitmapDataProvider>> it = highToBitmap.entrySet().iterator(); return toIterator(it, false); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs)... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { final Iterator<Map.Entry<Integer, BitmapDataProvider>> it = highToBitmap.entrySet().iterator(); return toIterator(it, false); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs)... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public LongIterator getLongIterator() { final Iterator<Map.Entry<Integer, BitmapDataProvider>> it = highToBitmap.entrySet().iterator(); return toIterator(it, false); } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs)... |
@Test public void testComparator() { Comparator<Integer> natural = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.compare(o1, o2); } }; Comparator<Integer> unsigned = RoaringIntPacking.unsignedComparator(); assertTrue(natural.compare(-1, 1) < 0); assertFalse(unsigned.c... | private int compare(int x, int y) { if (signedLongs) { return Integer.compare(x, y); } else { return RoaringIntPacking.compareUnsigned(x, y); } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { private int compare(int x, int y) { if (signedLongs) { return Integer.compare(x, y); } else { return RoaringIntPacking.compareUnsigned(x, y); } } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { private int compare(int x, int y) { if (signedLongs) { return Integer.compare(x, y); } else { return RoaringIntPacking.compareUnsigned(x, y); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { private int compare(int x, int y) { if (signedLongs) { return Integer.compare(x, y); } else { return RoaringIntPacking.compareUnsigned(x, y); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { private int compare(int x, int y) { if (signedLongs) { return Integer.compare(x, y); } else { return RoaringIntPacking.compareUnsigned(x, y); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean... |
@Test public void testSerialization_Empty() throws IOException, ClassNotFoundException { final Roaring64NavigableMap map = newDefaultCtor(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { oos.writeObject(map); } final Roaring64NavigableMap clone; ... | @Override public long getLongCardinality() { if (doCacheCardinalities) { if (highToBitmap.isEmpty()) { return 0L; } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return 0L; } return sortedCumulatedCardinality[indexOk - 1]; } else { long cardinality = 0L; for (BitmapDataProvider bitmap : ... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (doCacheCardinalities) { if (highToBitmap.isEmpty()) { return 0L; } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return 0L; } return sortedCumulatedCardinality[index... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (doCacheCardinalities) { if (highToBitmap.isEmpty()) { return 0L; } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return 0L; } return sortedCumulatedCardinality[index... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (doCacheCardinalities) { if (highToBitmap.isEmpty()) { return 0L; } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return 0L; } return sortedCumulatedCardinality[index... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long getLongCardinality() { if (doCacheCardinalities) { if (highToBitmap.isEmpty()) { return 0L; } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return 0L; } return sortedCumulatedCardinality[index... |
@Test public void testCardinalityAboveIntegerMaxValue_RoaringBitmap() { assertThrows(IllegalArgumentException.class, () -> { RoaringBitmap map = new RoaringBitmap(); map.add(0L, outOfRoaringBitmapRange); }); } | public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { public void add(long... dat) { for (long oneLong : dat) { addLong(oneLong); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinalities); Roaring64NavigableMap(... |
@Test public void testTrim() { Roaring64NavigableMap map = new Roaring64NavigableMap(true); int enableTrim = 100; long from = RoaringIntPacking.pack(0, -1 - enableTrim); long to = from + 2 * enableTrim; assertNotEquals(RoaringIntPacking.high(to), RoaringIntPacking.high(from)); for (long i = from; i <= to; i++) { map.ad... | @Override public void trim() { for (BitmapDataProvider bitmap : highToBitmap.values()) { bitmap.trim(); } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { for (BitmapDataProvider bitmap : highToBitmap.values()) { bitmap.trim(); } } } | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { for (BitmapDataProvider bitmap : highToBitmap.values()) { bitmap.trim(); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinaliti... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { for (BitmapDataProvider bitmap : highToBitmap.values()) { bitmap.trim(); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinaliti... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public void trim() { for (BitmapDataProvider bitmap : highToBitmap.values()) { bitmap.trim(); } } Roaring64NavigableMap(); Roaring64NavigableMap(boolean signedLongs); Roaring64NavigableMap(boolean signedLongs, boolean cacheCardinaliti... |
@Test public void testSelect_Empty() { assertThrows(IllegalArgumentException.class, () -> { Roaring64NavigableMap map = newUnsignedHeap(); map.select(0); }); } | @Override public long select(final long j) throws IllegalArgumentException { if (!doCacheCardinalities) { return selectNoCache(j); } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return throwSelectInvalidIndex(j); } int position = Arrays.binarySearch(sortedCumulatedCardinality, 0, indexO... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { if (!doCacheCardinalities) { return selectNoCache(j); } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return throwSelectInvalidIndex(j); ... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { if (!doCacheCardinalities) { return selectNoCache(j); } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return throwSelectInvalidIndex(j); ... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { if (!doCacheCardinalities) { return selectNoCache(j); } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return throwSelectInvalidIndex(j); ... | Roaring64NavigableMap implements Externalizable, LongBitmapDataProvider { @Override public long select(final long j) throws IllegalArgumentException { if (!doCacheCardinalities) { return selectNoCache(j); } int indexOk = ensureCumulatives(highestHigh()); if (highToBitmap.isEmpty()) { return throwSelectInvalidIndex(j); ... |
@Test public void testNames() { assertEquals(new BitmapContainer().getContainerName(), Container.ContainerNames[0]); assertEquals(new ArrayContainer().getContainerName(), Container.ContainerNames[1]); assertEquals(new RunContainer().getContainerName(), Container.ContainerNames[2]); } | public String getContainerName() { if (this instanceof BitmapContainer) { return ContainerNames[0]; } else if (this instanceof ArrayContainer) { return ContainerNames[1]; } else { return ContainerNames[2]; } } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public String getContainerName() { if (this instanceof BitmapContainer) { return ContainerNames[0]; } else if (this instanceof ArrayContainer) { return ContainerNames[1]; } else { return ContainerNames[2]; } } } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public String getContainerName() { if (this instanceof BitmapContainer) { return ContainerNames[0]; } else if (this instanceof ArrayContainer) { return ContainerNames[1]; } else { return ContainerNames[2]; } } } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public String getContainerName() { if (this instanceof BitmapContainer) { return ContainerNames[0]; } else if (this instanceof ArrayContainer) { return ContainerNames[1]; } else { return ContainerNames[2]; } } static ... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public String getContainerName() { if (this instanceof BitmapContainer) { return ContainerNames[0]; } else if (this instanceof ArrayContainer) { return ContainerNames[1]; } else { return ContainerNames[2]; } } static ... |
@Test public void RunContainerVSRunContainerAND() { ArrayList<RunContainer> set = new ArrayList<RunContainer>(); ArrayList<Container> setb = new ArrayList<Container>(); getSetOfRunContainers(set, setb); for (int k = 0; k < set.size(); ++k) { for (int l = 0; l < set.size(); ++l) { assertEquals(set.get(k), setb.get(k)); ... | @Override public Container and(ArrayContainer x) { ArrayContainer ac = new ArrayContainer(x.cardinality); if (this.nbrruns == 0) { return ac; } int rlepos = 0; int arraypos = 0; int rleval = (this.getValue(rlepos)); int rlelength = (this.getLength(rlepos)); while (arraypos < x.cardinality) { int arrayval = (x.content[a... | RunContainer extends Container implements Cloneable { @Override public Container and(ArrayContainer x) { ArrayContainer ac = new ArrayContainer(x.cardinality); if (this.nbrruns == 0) { return ac; } int rlepos = 0; int arraypos = 0; int rleval = (this.getValue(rlepos)); int rlelength = (this.getLength(rlepos)); while (a... | RunContainer extends Container implements Cloneable { @Override public Container and(ArrayContainer x) { ArrayContainer ac = new ArrayContainer(x.cardinality); if (this.nbrruns == 0) { return ac; } int rlepos = 0; int arraypos = 0; int rleval = (this.getValue(rlepos)); int rlelength = (this.getLength(rlepos)); while (a... | RunContainer extends Container implements Cloneable { @Override public Container and(ArrayContainer x) { ArrayContainer ac = new ArrayContainer(x.cardinality); if (this.nbrruns == 0) { return ac; } int rlepos = 0; int arraypos = 0; int rleval = (this.getValue(rlepos)); int rlelength = (this.getLength(rlepos)); while (a... | RunContainer extends Container implements Cloneable { @Override public Container and(ArrayContainer x) { ArrayContainer ac = new ArrayContainer(x.cardinality); if (this.nbrruns == 0) { return ac; } int rlepos = 0; int arraypos = 0; int rleval = (this.getValue(rlepos)); int rlelength = (this.getLength(rlepos)); while (a... |
@Test public void inotTest1() { final char[] content = {1, 3, 5, 7, 9}; Container c = makeContainer(content); c = c.inot(0, 65536); final char[] s = new char[65536 - content.length]; int pos = 0; for (int i = 0; i < 65536; ++i) { if (Arrays.binarySearch(content, (char) i) < 0) { s[pos++] = (char) i; } } assertTrue(chec... | public abstract Container inot(int rangeStart, int rangeEnd); | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Contain... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Contain... |
@Test public void inotTest2() { final char[] content = {1, 3, 5, 7, 9}; Container c = makeContainer(content); c = c.inot(0, 65535); c = c.inot(0, 65535); assertTrue(checkContent(c, content)); } | public abstract Container inot(int rangeStart, int rangeEnd); | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Contain... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container inot(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Contain... |
@Test public void notTest1() { final char[] content = {1, 3, 5, 7, 9}; final Container c = makeContainer(content); final Container c1 = c.not(0, 65536); final char[] s = new char[65536 - content.length]; int pos = 0; for (int i = 0; i < 65536; ++i) { if (Arrays.binarySearch(content, (char) i) < 0) { s[pos++] = (char) i... | public abstract Container not(int rangeStart, int rangeEnd); | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Containe... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Containe... |
@Test public void notTest2() { final char[] content = {1, 3, 5, 7, 9}; final Container c = makeContainer(content); final Container c1 = c.not(0, 65535); final Container c2 = c1.not(0, 65535); assertTrue(checkContent(c2, content)); } | public abstract Container not(int rangeStart, int rangeEnd); | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Containe... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container not(int rangeStart, int rangeEnd); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Containe... |
@Test public void numberOfRuns() { char[] positions = {3, 4, 5, 10, 11, 13, 15, 62, 63, 64, 65}; Container ac = new ArrayContainer(); Container bc = new BitmapContainer(); Container rc = new RunContainer(); for (char position : positions) { ac.add(position); bc.add(position); rc.add(position); } assertEquals(rc.numberO... | abstract int numberOfRuns(); | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { abstract int numberOfRuns(); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { abstract int numberOfRuns(); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { abstract int numberOfRuns(); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(ArrayContainer x); abstrac... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { abstract int numberOfRuns(); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(ArrayContainer x); abstrac... |
@Test public void rangeOfOnesTest2A() { final Container c = Container.rangeOfOnes(1000, 35001); final char s[] = new char[35000 - 1000 + 1]; for (int i = 1000; i <= 35000; ++i) { s[i - 1000] = (char) i; } assertTrue(checkContent(c, s)); } | public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new ArrayContainer(start, last); } return new RunContainer(start, last); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... |
@Test public void rangeOfOnesTest3() { Container.rangeOfOnes(1, ArrayContainer.DEFAULT_MAX_SIZE); } | public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new ArrayContainer(start, last); } return new RunContainer(start, last); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... |
@Test public void rangeOfOnesTest4() { Container.rangeOfOnes(1, ArrayContainer.DEFAULT_MAX_SIZE + 2); } | public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new ArrayContainer(start, last); } return new RunContainer(start, last); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public static Container rangeOfOnes(final int start, final int last) { final int arrayContainerOverRunThreshold = 2; final int cardinality = last - start; if (cardinality <= arrayContainerOverRunThreshold) { return new... |
@Test public void testConsistentToString() { ArrayContainer ac = new ArrayContainer(); BitmapContainer bc = new BitmapContainer(); RunContainer rc = new RunContainer(); for (char i : new char[]{0, 2, 17, Short.MAX_VALUE, (char)-3, (char)-1}) { ac.add(i); bc.add(i); rc.add(i); } String expected = "{0,2,17,32767,65533,65... | public abstract Container add(int begin, int end); | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container add(int begin, int end); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container add(int begin, int end); } | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container add(int begin, int end); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(Arra... | Container implements Iterable<Character>, Cloneable, Externalizable,
WordStorage<Container> { public abstract Container add(int begin, int end); static Container rangeOfOnes(final int start, final int last); abstract Container add(int begin, int end); abstract Container add(char x); abstract Container and(Arra... |
@Test public void testEmptyBitSet() { final BitSet bitset = new BitSet(); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void RunContainerVSRunContainerANDNOT() { ArrayList<RunContainer> set = new ArrayList<RunContainer>(); ArrayList<Container> setb = new ArrayList<Container>(); getSetOfRunContainers(set, setb); for (int k = 0; k < set.size(); ++k) { for (int l = 0; l < set.size(); ++l) { assertEquals(set.get(k), setb.get(k)... | @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) { ArrayContainer ac = new ArrayContainer(card); ac.card... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... | RunContainer extends Container implements Cloneable { @Override public Container andNot(ArrayContainer x) { final int arbitrary_threshold = 32; if (x.getCardinality() < arbitrary_threshold) { return lazyandNot(x).toEfficientContainer(); } final int card = getCardinality(); if (card <= ArrayContainer.DEFAULT_MAX_SIZE) {... |
@Test public void testFlipFlapBetweenRandomFullAndEmptyBitSet() { final Random random = new Random(); final int nbitsPerBlock = 1024 * Long.SIZE; final int blocks = 50; final BitSet bitset = new BitSet(nbitsPerBlock * blocks); for (int block = 0; block < blocks * nbitsPerBlock; block += nbitsPerBlock) { int type = rand... | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testFullBitSet() { final BitSet bitset = new BitSet(); final int nbits = 1024 * Long.SIZE * 50; bitset.set(0, nbits); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testGapBitmap() { for (int gap = 1; gap <= 4096; gap *= 2) { for (int offset = 300; offset < 3000; offset += 10) { BitSet bitset = new BitSet(); for (int k = 0; k < 100000; k += gap) { bitset.set(k + offset); } final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap... | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testRandomBitmap() { final Random random = new Random(1235); final int runs = 50; final int maxNbits = 500000; for (int i = 0; i < runs; i++) { final BitSet bitset = randomBitset(random, 0, random.nextInt(maxNbits)); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, ... | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testRandomBitmap_extended() { final Random random = new Random(1245); final int runs = 50; final int maxNbits = 500000; for (int i = 0; i < runs; i++) { final BitSet bitset = randomBitset(random, 100000, random.nextInt(maxNbits)); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBi... | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testSmallBitSet1() { final BitSet bitset = new BitSet(); bitset.set(1); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testSmallBitSet1_10000000() { final BitSet bitset = new BitSet(); bitset.set(1); bitset.set(10000000); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void testSmallBitSet10000000() { final BitSet bitset = new BitSet(); bitset.set(10000000); final RoaringBitmap bitmap = BitSetUtil.bitmapOf(bitset); assertEqualBitsets(bitset, bitmap); } | public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } | BitSetUtil { public static RoaringBitmap bitmapOf(final BitSet bitSet) { return bitmapOf(bitSet.toLongArray()); } static RoaringBitmap bitmapOf(final BitSet bitSet); static RoaringBitmap bitmapOf(final long[] words); static boolean equals(final BitSet bitset, final RoaringBitmap bitmap); } |
@Test public void RunContainerVSRunContainerOR() { ArrayList<RunContainer> set = new ArrayList<RunContainer>(); ArrayList<Container> setb = new ArrayList<Container>(); getSetOfRunContainers(set, setb); for (int k = 0; k < set.size(); ++k) { for (int l = 0; l < set.size(); ++l) { assertEquals(set.get(k), setb.get(k)); a... | @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } } | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, in... | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, in... | RunContainer extends Container implements Cloneable { @Override public Container or(ArrayContainer x) { return lazyor(x).repairAfterLazy(); } RunContainer(); protected RunContainer(ArrayContainer arr, int nbrRuns); RunContainer(final int firstOfRun, final int lastOfRun); protected RunContainer(BitmapContainer bc, in... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.