@Override public MappeableContainer or(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; final int totalCardinality = value1.getCardinality() + value2.getCardinality(); if (totalCardinality > DEFAULT_MAX_SIZE) { // it could be a bitmap! final MappeableBitmapContainer bc = new MappeableBitmapContainer(); if (!BufferUtil.isBackedBySimpleArray(bc.bitmap)) throw new RuntimeException("Should not happen. Internal bug."); long[] bitArray = bc.bitmap.array(); if (BufferUtil.isBackedBySimpleArray(value2.content)) { short[] sarray = value2.content.array(); for (int k = 0; k < value2.cardinality; ++k) { final int i = BufferUtil.toIntUnsigned(sarray[k]) >>> 6; bitArray[i] |= (1l << sarray[k]); } } else for (int k = 0; k < value2.cardinality; ++k) { short v2 = value2.content.get(k); final int i = BufferUtil.toIntUnsigned(v2) >>> 6; bitArray[i] |= (1l << v2); } if (BufferUtil.isBackedBySimpleArray(this.content)) { short[] sarray = this.content.array(); for (int k = 0; k < this.cardinality; ++k) { final int i = BufferUtil.toIntUnsigned(sarray[k]) >>> 6; bitArray[i] |= (1l << sarray[k]); } } else for (int k = 0; k < this.cardinality; ++k) { final int i = BufferUtil.toIntUnsigned(this.content.get(k)) >>> 6; bitArray[i] |= (1l << this.content.get(k)); } bc.cardinality = 0; int len = bc.bitmap.limit(); for (int index = 0; index < len; ++index) { bc.cardinality += Long.bitCount(bitArray[index]); } if (bc.cardinality <= DEFAULT_MAX_SIZE) return bc.toArrayContainer(); return bc; } final MappeableArrayContainer answer = new MappeableArrayContainer(totalCardinality); if (BufferUtil.isBackedBySimpleArray(value1.content) && BufferUtil.isBackedBySimpleArray(value2.content)) answer.cardinality = org.roaringbitmap.Util.unsignedUnion2by2( value1.content.array(), value1.getCardinality(), value2.content.array(), value2.getCardinality(), answer.content.array()); else answer.cardinality = BufferUtil.unsignedUnion2by2( value1.content, value1.getCardinality(), value2.content, value2.getCardinality(), answer.content.array()); return answer; }
@Override public MappeableContainer add(int begin, int end) { int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) begin); if (indexstart < 0) indexstart = -indexstart - 1; int indexend = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (end - 1)); if (indexend < 0) indexend = -indexend - 1; else indexend++; int rangelength = end - begin; int newcardinality = indexstart + (cardinality - indexend) + rangelength; if (newcardinality > DEFAULT_MAX_SIZE) { MappeableBitmapContainer a = this.toBitmapContainer(); return a.iadd(begin, end); } MappeableArrayContainer answer = new MappeableArrayContainer(newcardinality, content); if (!BufferUtil.isBackedBySimpleArray(answer.content)) throw new RuntimeException("Should not happen. Internal bug."); BufferUtil.arraycopy( content, indexend, answer.content, indexstart + rangelength, cardinality - indexend); short[] answerarray = answer.content.array(); for (int k = 0; k < rangelength; ++k) { answerarray[k + indexstart] = (short) (begin + k); } answer.cardinality = newcardinality; return answer; }
@Override public MappeableArrayContainer and(final MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; final int desiredCapacity = Math.min(value1.getCardinality(), value2.getCardinality()); MappeableArrayContainer answer = new MappeableArrayContainer(desiredCapacity); if (BufferUtil.isBackedBySimpleArray(this.content) && BufferUtil.isBackedBySimpleArray(value2.content)) answer.cardinality = org.roaringbitmap.Util.unsignedIntersect2by2( value1.content.array(), value1.getCardinality(), value2.content.array(), value2.getCardinality(), answer.content.array()); else answer.cardinality = BufferUtil.unsignedIntersect2by2( value1.content, value1.getCardinality(), value2.content, value2.getCardinality(), answer.content.array()); return answer; }
boolean validate(MappeableBitmapContainer bc, MappeableArrayContainer ac) { // Checking the cardinalities of each container if (bc.getCardinality() != ac.getCardinality()) { System.out.println("cardinality differs"); return false; } // Checking that the two containers contain the same values int counter = 0; int i = bc.nextSetBit(0); while (i >= 0) { ++counter; if (!ac.contains((short) i)) { System.out.println("content differs"); System.out.println(bc); System.out.println(ac); return false; } i = bc.nextSetBit(i + 1); } // checking the cardinality of the BitmapContainer return counter == bc.getCardinality(); }
@Test public void ContainerFactory() { MappeableBitmapContainer bc1, bc2, bc3; MappeableArrayContainer ac1, ac2, ac3; bc1 = new MappeableBitmapContainer(); bc2 = new MappeableBitmapContainer(); bc3 = new MappeableBitmapContainer(); ac1 = new MappeableArrayContainer(); ac2 = new MappeableArrayContainer(); ac3 = new MappeableArrayContainer(); for (short i = 0; i < 5000; i++) bc1.add((short) (i * 70)); for (short i = 0; i < 5000; i++) bc2.add((short) (i * 70)); for (short i = 0; i < 5000; i++) bc3.add((short) (i * 70)); for (short i = 0; i < 4000; i++) ac1.add((short) (i * 50)); for (short i = 0; i < 4000; i++) ac2.add((short) (i * 50)); for (short i = 0; i < 4000; i++) ac3.add((short) (i * 50)); MappeableBitmapContainer rbc; rbc = ac1.clone().toBitmapContainer(); Assert.assertTrue(validate(rbc, ac1)); rbc = ac2.clone().toBitmapContainer(); Assert.assertTrue(validate(rbc, ac2)); rbc = ac3.clone().toBitmapContainer(); Assert.assertTrue(validate(rbc, ac3)); }
@Test public void ArrayContainerCardinalityTest() { final MappeableArrayContainer ac = new MappeableArrayContainer(); for (short k = 0; k < 100; ++k) { ac.add(k); Assert.assertEquals(ac.getCardinality(), k + 1); } for (short k = 0; k < 100; ++k) { ac.add(k); Assert.assertEquals(ac.getCardinality(), 100); } }
@Test public void arraytest() { final MappeableArrayContainer rr = new MappeableArrayContainer(); rr.add((short) 110); rr.add((short) 114); rr.add((short) 115); final short[] array = new short[3]; int pos = 0; for (final short i : rr) array[pos++] = i; Assert.assertEquals(array[0], (short) 110); Assert.assertEquals(array[1], (short) 114); Assert.assertEquals(array[2], (short) 115); }
// shares lots of code with inot; candidate for refactoring @Override public MappeableContainer not(final int firstOfRange, final int lastOfRange) { // TODO: this can be optimized for performance if (firstOfRange >= lastOfRange) { return clone(); // empty range } // determine the span of array indices to be affected int startIndex = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) firstOfRange); if (startIndex < 0) startIndex = -startIndex - 1; int lastIndex = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (lastOfRange - 1)); if (lastIndex < 0) lastIndex = -lastIndex - 2; final int currentValuesInRange = lastIndex - startIndex + 1; final int spanToBeFlipped = lastOfRange - firstOfRange; final int newValuesInRange = spanToBeFlipped - currentValuesInRange; final int cardinalityChange = newValuesInRange - currentValuesInRange; final int newCardinality = cardinality + cardinalityChange; if (newCardinality > DEFAULT_MAX_SIZE) return toBitmapContainer().not(firstOfRange, lastOfRange); final MappeableArrayContainer answer = new MappeableArrayContainer(newCardinality); if (!BufferUtil.isBackedBySimpleArray(answer.content)) throw new RuntimeException("Should not happen. Internal bug."); short[] sarray = answer.content.array(); for (int i = 0; i < startIndex; ++i) // copy stuff before the active area sarray[i] = content.get(i); int outPos = startIndex; int inPos = startIndex; // item at inPos always >= valInRange int valInRange = firstOfRange; for (; valInRange < lastOfRange && inPos <= lastIndex; ++valInRange) { if ((short) valInRange != content.get(inPos)) sarray[outPos++] = (short) valInRange; else { ++inPos; } } for (; valInRange < lastOfRange; ++valInRange) { answer.content.put(outPos++, (short) valInRange); } // content after the active range for (int i = lastIndex + 1; i < cardinality; ++i) answer.content.put(outPos++, content.get(i)); answer.cardinality = newCardinality; return answer; }
/** * it must return items in (unsigned) sorted order. Possible candidate for Container interface? * */ private MappeableContainer or(ShortIterator it, boolean exclusive) { MappeableArrayContainer ac = new MappeableArrayContainer(); int myItPos = 0; ac.cardinality = 0; // do a merge. int -1 denotes end of input. int myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++)); int hisHead = advance(it); while (myHead != -1 && hisHead != -1) { if (myHead < hisHead) { ac.emit((short) myHead); myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++)); } else if (myHead > hisHead) { ac.emit((short) hisHead); hisHead = advance(it); } else { if (!exclusive) ac.emit((short) hisHead); hisHead = advance(it); myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++)); } } while (myHead != -1) { ac.emit((short) myHead); myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++)); } while (hisHead != -1) { ac.emit((short) hisHead); hisHead = advance(it); } if (ac.cardinality > DEFAULT_MAX_SIZE) return ac.toBitmapContainer(); else return ac; }
@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.content, value1.getCardinality(), value2.content, value2.getCardinality(), value1.content.array()); return this; }
@Override public MappeableArrayContainer andNot(MappeableBitmapContainer value2) { final MappeableArrayContainer answer = new MappeableArrayContainer(content.limit()); int pos = 0; short[] sarray = answer.content.array(); if (BufferUtil.isBackedBySimpleArray(this.content)) { short[] c = content.array(); for (int k = 0; k < cardinality; ++k) if (!value2.contains(c[k])) sarray[pos++] = c[k]; } else for (int k = 0; k < cardinality; ++k) { short v = this.content.get(k); if (!value2.contains(v)) sarray[pos++] = v; } answer.cardinality = pos; return answer; }
@Override public MappeableContainer remove(int begin, int end) { int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) begin); if (indexstart < 0) indexstart = -indexstart - 1; int indexend = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (end - 1)); if (indexend < 0) indexend = -indexend - 1; else indexend++; int rangelength = indexend - indexstart; MappeableArrayContainer answer = clone(); BufferUtil.arraycopy( content, indexstart + rangelength, answer.content, indexstart, cardinality - indexstart - rangelength); answer.cardinality = cardinality - rangelength; return answer; }
@Override public MappeableArrayContainer iandNot(final MappeableArrayContainer value2) { if (!BufferUtil.isBackedBySimpleArray(this.content)) throw new RuntimeException("Should not happen. Internal bug."); if (BufferUtil.isBackedBySimpleArray(value2.content)) this.cardinality = org.roaringbitmap.Util.unsignedDifference( this.content.array(), this.getCardinality(), value2.content.array(), value2.getCardinality(), this.content.array()); else this.cardinality = BufferUtil.unsignedDifference( this.content, this.getCardinality(), value2.content, value2.getCardinality(), this.content.array()); return this; }
@Override public void remove() { parent.remove((short) (pos + 1)); pos++; }
RawReverseArrayContainerShortIterator(MappeableArrayContainer p) { parent = p; if (!p.isArrayBacked()) throw new RuntimeException("internal bug"); content = p.content.array(); pos = parent.cardinality - 1; }