public static RoaringBitset and(RoaringBitset x1,
RoaringBitset x2)
{
RoaringBitset answer = new RoaringBitset();
int length1 = x1.containers.size, length2 = x2.containers.size;
int pos1 = 0, pos2 = 0;
while (pos1 < length1 && pos2 < length2) {
ushort s1 = x1.containers.getKeyAtIndex(pos1);
ushort s2 = x2.containers.getKeyAtIndex(pos2);
if (s1 == s2) {
Container c1 = x1.containers.getContainerAtIndex(pos1);
Container c2 = x2.containers.getContainerAtIndex(pos2);
Container c = c1.and(c2);
if (c.getCardinality() > 0) {
answer.containers.append(s1, c);
}
++pos1;
++pos2;
} else if (s1 < s2 ) { // s1 < s2
pos1 = x1.containers.advanceUntil(s2, pos1);
} else { // s1 > s2
pos2 = x2.containers.advanceUntil(s1, pos2);
}
}
return answer;
}
public static RoaringBitset Create(int[] input)
{
RoaringBitset rb = new RoaringBitset();
foreach (int i in input) {
rb.add(i);
}
return rb;
}
/// <summary>
/// Read a binary serialization of a roaring bitset, as written by the Serialize method.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <returns>The bitset deserialized from the stream.</returns>
public static RoaringBitset Deserialize(Stream stream)
{
RoaringBitset bitset = new RoaringBitset();
//We don't care about the encoding, but we have to specify something to be able to set the stream as leave open.
using (BinaryReader reader = new BinaryReader(stream, Encoding.Default, true))
{
bitset.containers = RoaringArray.Deserialize(reader);
}
return bitset;
}
/// <summary>
/// Creates a new bitset that is the bitwise OR of this bitset with another
/// </summary>
/// <param name="otherSet">Other bitset</param>
/// <returns>A new IBitset</returns>
public IBitset Or(IBitset otherSet)
{
if (!(otherSet is RoaringBitset))
{
throw new ArgumentOutOfRangeException("otherSet must be a RoaringBitSet");
}
RoaringBitset answer = new RoaringBitset();
RoaringBitset x2 = (RoaringBitset)otherSet;
int pos1 = 0, pos2 = 0;
int thisSize = this.containers.Size;
int otherSetSize = x2.containers.Size;
if (pos1 < thisSize && pos2 < otherSetSize)
{
ushort s1 = this.containers.GetKeyAtIndex(pos1);
ushort s2 = x2.containers.GetKeyAtIndex(pos2);
while (true)
{
if (s1 == s2)
{
Container newContainer = this.containers.GetContainerAtIndex(pos1)
.Or(x2.containers.GetContainerAtIndex(pos2));
answer.containers.Append(s1, newContainer);
pos1++;
pos2++;
if ((pos1 == thisSize) || (pos2 == otherSetSize))
{
break;
}
s1 = this.containers.GetKeyAtIndex(pos1);
s2 = x2.containers.GetKeyAtIndex(pos2);
}
else if (s1 < s2)
{
answer.containers.AppendCopy(this.containers, pos1);
pos1++;
if (pos1 == thisSize)
{
break;
}
s1 = this.containers.GetKeyAtIndex(pos1);
}
else // s1 > s2
{
answer.containers.AppendCopy(x2.containers, pos2);
pos2++;
if (pos2 == otherSetSize)
{
break;
}
s2 = x2.containers.GetKeyAtIndex(pos2);
}
}
}
if (pos1 == thisSize)
{
answer.containers.AppendCopy(x2.containers, pos2, otherSetSize);
}
else if (pos2 == otherSetSize)
{
answer.containers.AppendCopy(this.containers, pos1, thisSize);
}
return(answer);
}
/// <summary>
/// Computes the in-place bitwise OR of this bitset with another
/// </summary>
/// <param name="otherSet">Other bitset</param>
public void OrWith(IBitset otherSet)
{
if (!(otherSet is RoaringBitset))
{
throw new ArgumentOutOfRangeException("otherSet must be a RoaringBitSet");
}
RoaringBitset x2 = (RoaringBitset)otherSet;
int pos1 = 0, pos2 = 0;
int length1 = this.containers.Size, length2 = x2.containers.Size;
if (pos1 < length1 && pos2 < length2)
{
ushort s1 = this.containers.GetKeyAtIndex(pos1);
ushort s2 = x2.containers.GetKeyAtIndex(pos2);
while (true)
{
if (s1 == s2)
{
Container newContainer = this.containers.GetContainerAtIndex(pos1)
.IOr(x2.containers.GetContainerAtIndex(pos2));
this.containers.SetContainerAtIndex(pos1, newContainer);
pos1++;
pos2++;
if ((pos1 == length1) || (pos2 == length2))
{
break;
}
s1 = this.containers.GetKeyAtIndex(pos1);
s2 = x2.containers.GetKeyAtIndex(pos2);
}
else if (s1 < s2)
{
pos1++;
if (pos1 == length1)
{
break;
}
s1 = this.containers.GetKeyAtIndex(pos1);
}
else
{ // s1 > s2
this.containers.InsertNewKeyValueAt(pos1, s2, x2.containers.GetContainerAtIndex(pos2));
pos1++;
length1++;
pos2++;
if (pos2 == length2)
{
break;
}
s2 = x2.containers.GetKeyAtIndex(pos2);
}
}
}
if (pos1 == length1)
{
this.containers.AppendCopy(x2.containers, pos2, length2);
}
}
public static RoaringBitset Or(RoaringBitset x1, RoaringBitset x2)
{
return((RoaringBitset)x1.Or(x2));
}
/// <summary>
/// Finds members of this bitset that are not in the other set (ANDNOT).
/// Modifies current bitset in place.
/// </summary>
/// <param name="otherSet">The set to compare against</param>
public void iandNot(RoaringBitset otherSet)
{
int pos1 = 0, pos2 = 0, intersectionSize = 0;
int length1 = containers.size, length2 = otherSet.containers.size;
while (pos1 < length1 && pos2 < length2)
{
ushort s1 = containers.getKeyAtIndex(pos1);
ushort s2 = otherSet.containers.getKeyAtIndex(pos2);
if (s1 == s2)
{
Container c1 = containers.getContainerAtIndex(pos1);
Container c2 = otherSet.containers.getContainerAtIndex(pos2);
Container c = c1.iandNot(c2);
if (c.getCardinality() > 0)
{
containers.replaceKeyAndContainerAtIndex(intersectionSize++, s1, c);
}
++pos1;
++pos2;
}
else if (Utility.compareUnsigned(s1, s2) < 0)
{ // s1 < s2
if (pos1 != intersectionSize)
{
Container c1 = containers.getContainerAtIndex(pos1);
containers.replaceKeyAndContainerAtIndex(intersectionSize, s1, c1);
}
++intersectionSize;
++pos1;
}
else
{ // s1 > s2
pos2 = otherSet.containers.advanceUntil(s1, pos2);
}
}
if (pos1 < length1)
{
containers.copyRange(pos1, length1, intersectionSize);
intersectionSize += length1 - pos1;
}
containers.resize(intersectionSize);
}
/// <summary>
/// Finds members of a bitset that are not in the other set (ANDNOT).
/// This does not modify either bitset.
/// </summary>
/// <param name="otherSet">The set to compare against</param>
/// <returns>A new IBitset containing the members that are in
/// the first bitset but not in the second.</returns>
public IBitset andNot(RoaringBitset otherSet)
{
RoaringBitset answer = new RoaringBitset();
int pos1 = 0, pos2 = 0;
int length1 = containers.size, length2 = otherSet.containers.size;
while (pos1 < length1 && pos2 < length2)
{
ushort s1 = containers.getKeyAtIndex(pos1);
ushort s2 = otherSet.containers.getKeyAtIndex(pos2);
if (s1 == s2)
{
Container c1 = containers.getContainerAtIndex(pos1);
Container c2 = otherSet.containers.getContainerAtIndex(pos2);
Container c = c1.andNot(c2);
if (c.getCardinality() > 0)
{
answer.containers.append(s1, c);
}
++pos1;
++pos2;
}
else if (Utility.compareUnsigned(s1, s2) < 0)
{ // s1 < s2
int nextPos1 = containers.advanceUntil(s2, pos1);
answer.containers.appendCopy(containers, pos1, nextPos1);
pos1 = nextPos1;
}
else
{ // s1 > s2
pos2 = otherSet.containers.advanceUntil(s1, pos2);
}
}
if (pos2 == length2)
{
answer.containers.appendCopy(containers, pos1, length1);
}
return answer;
}
public IBitset Or(IBitset otherSet)
{
if (!(otherSet is RoaringBitset))
throw new ArgumentOutOfRangeException("otherSet must be a RoaringBitSet");
RoaringBitset answer = new RoaringBitset();
RoaringBitset x2 = (RoaringBitset) otherSet;
int pos1 = 0, pos2 = 0;
int length1 = this.containers.size, length2 = x2.containers.size;
if (pos1 < length1 && pos2 < length2) {
ushort s1 = this.containers.getKeyAtIndex(pos1);
ushort s2 = x2.containers.getKeyAtIndex(pos2);
while (true) {
if (s1 == s2) {
answer.containers.append(
s1,
this.containers.getContainerAtIndex(pos1).or(
x2.containers.getContainerAtIndex(pos2)
)
);
pos1++;
pos2++;
if ((pos1 == length1) || (pos2 == length2)) {
break;
}
s1 = this.containers.getKeyAtIndex(pos1);
s2 = x2.containers.getKeyAtIndex(pos2);
} else if (s1 < s2) {
answer.containers.appendCopy(this.containers, pos1);
pos1++;
if (pos1 == length1) {
break;
}
s1 = this.containers.getKeyAtIndex(pos1);
} else { // s1 > s2
answer.containers.appendCopy(x2.containers, pos2);
pos2++;
if (pos2 == length2) {
break;
}
s2 = x2.containers.getKeyAtIndex(pos2);
}
}
}
if (pos1 == length1) {
answer.containers.appendCopy(x2.containers, pos2, length2);
} else if (pos2 == length2) {
answer.containers.appendCopy(this.containers, pos1, length1);
}
return answer;
}
public IBitset Clone()
{
RoaringBitset x = new RoaringBitset();
x.containers = containers.clone();
return x;
}
/// <summary>
/// Performs an in-place intersection of two Roaring Bitsets.
/// </summary>
/// <param name="other">the second Roaring Bitset to intersect</param>
private void andWith(RoaringBitset other)
{
int length1 = this.containers.size, length2 = other.containers.size;
int pos1 = 0, pos2 = 0, intersectionSize = 0;
while (pos1 < length1 && pos2 < length2)
{
ushort s1 = this.containers.getKeyAtIndex(pos1);
ushort s2 = other.containers.getKeyAtIndex(pos2);
if (s1 == s2)
{
Container c1 = this.containers.getContainerAtIndex(pos1);
Container c2 = other.containers.getContainerAtIndex(pos2);
Container c = c1.iand(c2);
if (c.getCardinality() > 0)
{
this.containers.replaceKeyAndContainerAtIndex(intersectionSize++, s1, c);
}
++pos1;
++pos2;
}
else if (s1 < s2)
{ // s1 < s2
pos1 = this.containers.advanceUntil(s2, pos1);
}
else
{ // s1 > s2
pos2 = other.containers.advanceUntil(s1, pos2);
}
}
this.containers.resize(intersectionSize);
}
/// <summary>
/// Performs an in-place intersection of two Roaring Bitsets.
/// </summary>
/// <param name="other">the second Roaring Bitset to intersect</param>
private void AndWith(RoaringBitset other)
{
int thisLength = this.containers.Size;
int otherLength = other.containers.Size;
int pos1 = 0, pos2 = 0, intersectionSize = 0;
while (pos1 < thisLength && pos2 < otherLength)
{
ushort s1 = this.containers.GetKeyAtIndex(pos1);
ushort s2 = other.containers.GetKeyAtIndex(pos2);
if (s1 == s2)
{
Container c1 = this.containers.GetContainerAtIndex(pos1);
Container c2 = other.containers.GetContainerAtIndex(pos2);
Container c = c1.IAnd(c2);
if (c.GetCardinality() > 0)
{
this.containers.ReplaceKeyAndContainerAtIndex(intersectionSize++, s1, c);
}
++pos1;
++pos2;
}
else if (s1 < s2)
{ // s1 < s2
pos1 = this.containers.AdvanceUntil(s2, pos1);
}
else
{ // s1 > s2
pos2 = other.containers.AdvanceUntil(s1, pos2);
}
}
this.containers.Resize(intersectionSize);
}
/// <summary>
/// Creates a new bitset that is the bitwise OR of this bitset with another
/// </summary>
/// <param name="otherSet">Other bitset</param>
/// <returns>A new IBitset</returns>
public IBitset Or(IBitset otherSet)
{
if (!(otherSet is RoaringBitset))
{
throw new ArgumentOutOfRangeException("otherSet must be a RoaringBitSet");
}
RoaringBitset answer = new RoaringBitset();
RoaringBitset x2 = (RoaringBitset) otherSet;
int pos1 = 0, pos2 = 0;
int thisSize = this.containers.Size;
int otherSetSize = x2.containers.Size;
if (pos1 < thisSize && pos2 < otherSetSize)
{
ushort s1 = this.containers.GetKeyAtIndex(pos1);
ushort s2 = x2.containers.GetKeyAtIndex(pos2);
while (true)
{
if (s1 == s2)
{
Container newContainer = this.containers.GetContainerAtIndex(pos1)
.Or(x2.containers.GetContainerAtIndex(pos2));
answer.containers.Append(s1, newContainer);
pos1++;
pos2++;
if ((pos1 == thisSize) || (pos2 == otherSetSize))
{
break;
}
s1 = this.containers.GetKeyAtIndex(pos1);
s2 = x2.containers.GetKeyAtIndex(pos2);
}
else if (s1 < s2)
{
answer.containers.AppendCopy(this.containers, pos1);
pos1++;
if (pos1 == thisSize)
{
break;
}
s1 = this.containers.GetKeyAtIndex(pos1);
}
else // s1 > s2
{
answer.containers.AppendCopy(x2.containers, pos2);
pos2++;
if (pos2 == otherSetSize)
{
break;
}
s2 = x2.containers.GetKeyAtIndex(pos2);
}
}
}
if (pos1 == thisSize)
{
answer.containers.AppendCopy(x2.containers, pos2, otherSetSize);
}
else if (pos2 == otherSetSize)
{
answer.containers.AppendCopy(this.containers, pos1, thisSize);
}
return answer;
}
/// <summary>
/// Finds members of this bitset that are not in the other set (ANDNOT).
/// Modifies current bitset in place.
/// </summary>
/// <param name="otherSet">The set to compare against</param>
public void IAndNot(RoaringBitset otherSet)
{
int pos1 = 0, pos2 = 0, intersectionSize = 0;
int thisSize = containers.Size;
int otherSetSize = otherSet.containers.Size;
while (pos1 < thisSize && pos2 < otherSetSize)
{
ushort s1 = containers.GetKeyAtIndex(pos1);
ushort s2 = otherSet.containers.GetKeyAtIndex(pos2);
if (s1 == s2)
{
Container c1 = containers.GetContainerAtIndex(pos1);
Container c2 = otherSet.containers.GetContainerAtIndex(pos2);
Container c = c1.IAndNot(c2);
if (c.GetCardinality() > 0)
{
containers.ReplaceKeyAndContainerAtIndex(intersectionSize++, s1, c);
}
++pos1;
++pos2;
}
else if (Utility.CompareUnsigned(s1, s2) < 0)
{ // s1 < s2
if (pos1 != intersectionSize)
{
Container c1 = containers.GetContainerAtIndex(pos1);
containers.ReplaceKeyAndContainerAtIndex(intersectionSize, s1, c1);
}
++intersectionSize;
++pos1;
}
else
{ // s1 > s2
pos2 = otherSet.containers.AdvanceUntil(s1, pos2);
}
}
if (pos1 < thisSize)
{
containers.CopyRange(pos1, thisSize, intersectionSize);
intersectionSize += thisSize - pos1;
}
containers.Resize(intersectionSize);
}
