Java RoaringBitmap.and方法代码示例

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
static void solve(RoaringBitmap[] bits, int depth, int bitIndex, RoaringBitmap candidate, boolean[] output, Solution solution) {

        RoaringBitmap zero = RoaringBitmap.andNot(candidate, bits[bitIndex]);
        RoaringBitmap ones = RoaringBitmap.and(candidate, bits[bitIndex]);
        if (bitIndex > 0) {
            output[bitIndex] = true;
            solve(bits, depth + 1, bitIndex - 1, ones, output, solution);
        } else if (!ones.isEmpty()) {
            output[bitIndex] = true;
            solution.stream(output, ones.getCardinality());
        }
        if (bitIndex > 0) {
            output[bitIndex] = false;
            solve(bits, depth + 1, bitIndex - 1, zero, output, solution);
        } else if (!zero.isEmpty()) {
            output[bitIndex] = false;
            solution.stream(output, zero.getCardinality());
        }
    }
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
@Override
public void inPlaceAnd(RoaringBitmap original, RoaringBitmap bitmap) {
    try {
        original.and(bitmap);
    } catch (Throwable t) {
        LOG.error("WTF:" + original.getCardinality() + " inPlaceAnd " + bitmap.getCardinality());
        throw t;
    }
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
@Override
public RoaringBitmap andTx(List<MiruTxIndex<RoaringBitmap>> indexes, StackBuffer stackBuffer) throws Exception {
    if (indexes.isEmpty()) {
        return new RoaringBitmap();
    }

    RoaringBitmap container = indexes.get(0).txIndex((bitmap, filer, offset, stackBuffer1) -> {
        if (bitmap != null) {
            return bitmap;
        } else if (filer != null) {
            return bitmapFromFiler(filer, offset, stackBuffer1);
        } else {
            return new RoaringBitmap();
        }
    }, stackBuffer);

    if (container.isEmpty()) {
        return container;
    }

    for (MiruTxIndex<RoaringBitmap> index : indexes.subList(1, indexes.size())) {
        RoaringBitmap and = index.txIndex((bitmap, filer, offset, stackBuffer1) -> {
            if (bitmap != null) {
                return bitmap;
            } else if (filer != null) {
                return bitmapFromFiler(filer, offset, stackBuffer1);
            } else {
                return new RoaringBitmap();
            }
        }, stackBuffer);

        container.and(and);

        if (container.isEmpty()) {
            return container;
        }
    }

    return container;
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
@Override
public RoaringBitmap[] add(RoaringBitmap... set) {
    final int numSumBitmaps = 32 - Integer.numberOfLeadingZeros(set.length);
    int lastBitSlice = 0;
    RoaringBitmap[] acc = new RoaringBitmap[numSumBitmaps + 1]; // null
                                                                // sentinel
                                                                // at end
    acc[0] = set[0];
    for (int k = 1; k < set.length; ++k) {
        RoaringBitmap c = RoaringBitmap.and(set[k], acc[0]);
        if (k == 1)
            acc[0] = RoaringBitmap.xor(acc[0], set[k]);
        else
            acc[0].xor(set[k]);
        int i;
        for (i = 1; acc[i] != null; ++i) {
            RoaringBitmap temp1 = RoaringBitmap.xor(acc[i], c);
            c.and(acc[i]);
            acc[i] = temp1;
        }

        if (!c.isEmpty()) {
            acc[i] = c;
            lastBitSlice = i;
        }
    }
    return Arrays.copyOf(acc, lastBitSlice + 1);

}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
/**
 * Returns as few bitmaps as needed, the first one carrying the least
 * significant bits.
 * 
 * @param a
 * @param b
 * @return
 */
public static RoaringBitmap[] add(RoaringBitmap[] a, RoaringBitmap[] b) {
    int mini = Math.min(a.length, b.length);
    int maxi = Math.max(a.length, b.length);
    ArrayList<RoaringBitmap> answer = new ArrayList<RoaringBitmap>(maxi + 1);
    int i = 0;
    RoaringBitmap carry = new RoaringBitmap();
    if (mini > 0) {
        answer.add(RoaringBitmap.xor(a[i], b[i]));
        carry = RoaringBitmap.and(a[i], b[i]);
        ++i;
    }
    for (; i < mini; ++i) {
        RoaringBitmap tmp = RoaringBitmap.xor(a[i], b[i]);
        answer.add(RoaringBitmap.xor(carry, tmp));
        carry.and(tmp);
        carry.or(RoaringBitmap.and(a[i], b[i]));
    }
    if (mini != maxi) {
        RoaringBitmap[] longest = a.length > b.length ? a : b;
        for (; i < maxi; ++i) {
            if (carry.isEmpty()) {
                answer.add(longest[i].clone());
            } else {
                answer.add(RoaringBitmap.xor(carry, longest[i]));
                carry.and(longest[i]);
            }
        }
    }
    if (!carry.isEmpty())
        answer.add(carry);
    return answer.toArray(a);
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
private List<RoaringBitmap> slowbuildHalfAdder(RoaringBitmap inputA,
        RoaringBitmap inputB) {
    List<RoaringBitmap> ans = new ArrayList<RoaringBitmap>();
    RoaringBitmap carryOut = RoaringBitmap.and(inputA, inputB);
    RoaringBitmap sumBit = RoaringBitmap.xor(inputA, inputB);
    ans.add(carryOut);
    ans.add(sumBit);
    return ans;
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
private List<RoaringBitmap> buildHalfAdder(RoaringBitmap inputA,
        RoaringBitmap inputB) {
    List<RoaringBitmap> ans = new ArrayList<RoaringBitmap>();
    RoaringBitmap carryOut = RoaringBitmap.and(inputA, inputB);
    inputA.xor(inputB);
    //RoaringBitmap sumBit = RoaringBitmap.xor(inputA, inputB);
    RoaringBitmap sumBit = inputA;
    ans.add(carryOut);
    ans.add(sumBit);
    return ans;
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
/**
 * Treating the bitmaps as a bit-sliced index, solve for >=K.
 * 
 * @param acc
 * @param K
 * @param universeSize
 * @return
 */
@Override
public RoaringBitmap compare(RoaringBitmap[] acc, int K, int universeSize) {
    int lastBitSlice = acc.length - 1;
    // use the O'Neil and Quass
    // comparison. (Algo 4.2)
    int beGtrThan = K - 1;

    RoaringBitmap beq = new RoaringBitmap();
    beq.flip(0, universeSize); // all ones bitmap
    RoaringBitmap bgt = new RoaringBitmap();

    int numberOfLeadingZeroSlices = 32 - (lastBitSlice + 1);
    if (Integer.numberOfLeadingZeros(beGtrThan) < numberOfLeadingZeroSlices)
        return bgt;

    // an improvement is that we can stop as soon as there are only trailing
    // ones in the constant.
    int finalSlice = 0;
    finalSlice = Integer.numberOfTrailingZeros(~beGtrThan); // omitted
                                                            // optimization

    for (int i = lastBitSlice; i >= finalSlice; --i)
        if ((beGtrThan & (1 << i)) != 0)
            beq.and(acc[i]);
        else {
            bgt.or(RoaringBitmap.and(beq, acc[i]));
            beq.andNot(acc[i]);
        }

    return bgt;

}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
private List<RoaringBitmap> buildFullAdder(RoaringBitmap inputA,
        RoaringBitmap inputB, RoaringBitmap inputC) {
    List<RoaringBitmap> ans = new ArrayList<RoaringBitmap>();
    RoaringBitmap temp1 = RoaringBitmap.xor(inputA, inputB);
    RoaringBitmap sumBit = RoaringBitmap.xor(temp1, inputC);
    temp1.and(inputC);
    inputA.and(inputB);
    temp1.or(inputA);
    RoaringBitmap carryOut = temp1;
    ans.add(carryOut);
    ans.add(sumBit); // added after carryOut
    return ans;
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
/**
 * Treating the bitmaps as a bit-sliced index, solve for >=K.
 * 
 * @param acc
 *            bitmaps in bit-sliced format
 * @param K
 *            threshold (>=)
 * @param universeSize
 *            useless here
 * @return
 */
@Override
public RoaringBitmap compare(RoaringBitmap[] acc, int K, int universeSize) {
    RoaringBitmap lastSpineGate = null;
    int beGtrThan = K - 1;
    ArrayList<RoaringBitmap> orInputs = new ArrayList<RoaringBitmap>();
    int leastSignifZero = Long.numberOfTrailingZeros(~beGtrThan);
    // work from most significant bit down to the last 1.
    for (int workingBit = acc.length - 1; workingBit >= leastSignifZero; --workingBit) {
        if ((beGtrThan & (1L << workingBit)) == 0L) {
            if (lastSpineGate == null) // don't make a singleton AND!
                orInputs.add(acc[workingBit]);
            else {
                // really make the AND
                orInputs.add(RoaringBitmap.and(lastSpineGate,
                        acc[workingBit]));
            }
        } else {
            if (lastSpineGate == null)
                lastSpineGate = acc[workingBit];
            else
                lastSpineGate = RoaringBitmap.and(lastSpineGate,
                        acc[workingBit]);
        }
    }
    return FastAggregation.or(orInputs.toArray(new RoaringBitmap[0]));
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
/**
 * Treating the bitmaps as a bit-sliced index, solve for >=K.
 * 
 * @param acc
 *            bitmaps in bit-sliced format
 * @param K
 *            threshold (>=)
 * @param universeSize
 *            useless here
 * @return
 */
@Override
public RoaringBitmap compare(RoaringBitmap[] acc, int K, int universeSize) {
    RoaringBitmap lastSpineGate = null;
    int beGtrThan = K - 1;
    ArrayList<RoaringBitmap> orInputs = new ArrayList<RoaringBitmap>();
    int leastSignifZero = Long.numberOfTrailingZeros(~beGtrThan);
    // work from most significant bit down to the last 1.
    for (int workingBit = acc.length - 1; workingBit >= leastSignifZero; --workingBit) {
        if ((beGtrThan & (1L << workingBit)) == 0L) {
            if (lastSpineGate == null) // don't make a singleton AND!
                orInputs.add(acc[workingBit]);
            else {
                // really make the AND
                orInputs.add(RoaringBitmap.and(lastSpineGate,
                        acc[workingBit]));
            }
        } else {
            if (lastSpineGate == null)
                lastSpineGate = acc[workingBit];
            else
                lastSpineGate = RoaringBitmap.and(lastSpineGate,
                        acc[workingBit]);
        }
    }
    return FastAggregation.horizontal_or(orInputs.toArray(new RoaringBitmap[0]));
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
@Override
public Bitmap and(Bitmap other) {
  return new RoaringBitmapWrapper(
      RoaringBitmap.and(bitmap, ((RoaringBitmapWrapper) other).bitmap));
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
@Override
public boolean containsAll(RoaringBitmap container, RoaringBitmap contained) {
    RoaringBitmap intersection = RoaringBitmap.and(container, contained);
    return intersection.getCardinality() == contained.getCardinality();
}
 

import org.roaringbitmap.RoaringBitmap; //导入方法依赖的package包/类
@Override
public boolean containsAny(RoaringBitmap container, RoaringBitmap contained) {
    RoaringBitmap intersection = RoaringBitmap.and(container, contained);
    return !intersection.isEmpty();
}