/**
* This is the standard liveness calculation (Dragon Book, section 10.6). At each BB (and its
* corresponding usage), we evaluate "in" using use and def. in = use U (out \ def) where out = U
* succ.in, for all successors
*
* <p>this algorithm has been modified to treat catch blocks as occurring anywhere ie, that vars
* defined in a try may never be set however, this only applies to vars that have been defined at
* least once (ie, born)
*/
public boolean evalLiveIn(ArrayList<Usage> succUsage, ArrayList<Handler> handUsage) {
BitSet out = new BitSet(nLocals);
BitSet old_in = (BitSet) in.clone();
if (handUsage == null) handUsage = new ArrayList();
if (succUsage.size() == 0) {
in = use;
} else {
// calculate out = U succ.in
out = (BitSet) succUsage.get(0).in.clone();
for (int i = 1; i < succUsage.size(); i++) {
out.or(succUsage.get(i).in);
}
// calc out \ def == out & ~def == ~(out | def)
// unless a var has been def'd in all catch blocks, assume it may fail to def
BitSet def1 = (BitSet) def.clone();
for (Handler handle : handUsage) def1.and(handle.catchBB.usage.def);
def1.flip(0, nLocals);
out.and(def1);
for (Handler handler : handUsage) out.or(handler.catchBB.usage.use);
// catch block vars may be def'd in this block, but we can't easily know if the
// def has occurred before the throw
// if the var has never been def'd (or was a parameter), then it can't be live
out.and(born);
out.or(use);
in = out;
}
return !(in.equals(old_in));
}
@Override
public final void filter(List<IRow> data, BitSet mask, BitSet mask_filteredOutInfluenceRanking) {
if (!isFiltered()) return;
if (!maskInvalid.isEmpty()) {
BitSet todo = (BitSet) maskInvalid.clone();
todo.and(mask);
updateMask(todo, data, this.mask);
maskInvalid.andNot(todo);
}
mask.and(this.mask);
if (!isRankIndependentFilter) // mark that the masked out are persistent
mask_filteredOutInfluenceRanking.and(this.mask);
}
/**
* Called to coalesce a successor's usage into the current BB. Important: This should be called
* before live variable analysis begins, because we don't bother merging this.in or this.born.
*/
void absorb(Usage succ) {
BitSet b = (BitSet) this.def.clone();
b.flip(0, nLocals);
b.and(succ.use);
this.use.or(b);
this.def.or(succ.def);
}
public static void main(String[] args) {
BitSet bits1 = new BitSet(16);
BitSet bits2 = new BitSet(16);
for (int i = 0; i < 16; i++) {
if ((i % 2) == 0) bits1.set(i);
if ((i % 5) != 0) bits2.set(i);
}
System.out.println("Initial pattern in bits1: ");
System.out.println(bits1);
System.out.println("\nInitial pattern in bits2: ");
System.out.println(bits2);
// AND bits
bits2.and(bits1);
System.out.println("\nbits2 AND bits1: ");
System.out.println(bits2);
// OR bits
bits2.or(bits1);
System.out.println("\nbits2 OR bits1: ");
System.out.println(bits2);
// XOR bits
bits2.xor(bits1);
System.out.println("\nbits2 XOR bits1: ");
System.out.println(bits2);
}
/** Find non-locals variables. Algorithm from Briggs, Cooper, Harvey and Simpson */
public BitSet findNonLocals() {
BitSet nonLocals = new BitSet(nbVar);
BitSet killed = new BitSet(nbVar);
BitSet emptySet = new BitSet(nbVar);
for (BasicBlock bb = firstBB; bb != null; bb = bb.getNext()) {
// clear killed set
killed.and(emptySet);
Iterator insts = bb.getInstructions();
while (insts.hasNext()) {
QInst inst = (QInst) insts.next();
QOperandBox[] ops = inst.getUses();
for (int i = 0; i < ops.length; ++i) {
QOperand op = ops[i].getOperand();
if (op instanceof QVar) {
int r = ((QVar) op).getRegister();
if (!killed.get(r)) {
nonLocals.set(r);
}
}
}
if (inst.defVar()) {
QOperand op = inst.getDefined().getOperand();
if (op instanceof QVar) {
int r = ((QVar) op).getRegister();
killed.set(r);
}
}
}
}
return nonLocals;
}
/**
* Prob0 precomputation algorithm. i.e. determine the states of an STPG which, with min/max
* probability 0, reach a state in {@code target}, while remaining in those in @{code remain}.
* {@code min}=true gives Prob0E, {@code min}=false gives Prob0A.
*
* @param stpg The STPG
* @param remain Remain in these states (optional: null means "all")
* @param target Target states
* @param min1 Min or max probabilities for player 1 (true=lower bound, false=upper bound)
* @param min2 Min or max probabilities for player 2 (true=min, false=max)
*/
public BitSet prob0(STPG stpg, BitSet remain, BitSet target, boolean min1, boolean min2) {
int n, iters;
BitSet u, soln, unknown;
boolean u_done;
long timer;
// Start precomputation
timer = System.currentTimeMillis();
if (verbosity >= 1)
mainLog.println(
"Starting Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")...");
// Special case: no target states
if (target.cardinality() == 0) {
soln = new BitSet(stpg.getNumStates());
soln.set(0, stpg.getNumStates());
return soln;
}
// Initialise vectors
n = stpg.getNumStates();
u = new BitSet(n);
soln = new BitSet(n);
// Determine set of states actually need to perform computation for
unknown = new BitSet();
unknown.set(0, n);
unknown.andNot(target);
if (remain != null) unknown.and(remain);
// Fixed point loop
iters = 0;
u_done = false;
// Least fixed point - should start from 0 but we optimise by
// starting from 'target', thus bypassing first iteration
u.or(target);
soln.or(target);
while (!u_done) {
iters++;
// Single step of Prob0
stpg.prob0step(unknown, u, min1, min2, soln);
// Check termination
u_done = soln.equals(u);
// u = soln
u.clear();
u.or(soln);
}
// Negate
u.flip(0, n);
// Finished precomputation
timer = System.currentTimeMillis() - timer;
if (verbosity >= 1) {
mainLog.print("Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")");
mainLog.println(" took " + iters + " iterations and " + timer / 1000.0 + " seconds.");
}
return u;
}
private boolean match(BitSet bitset, BitSet other) {
BitSet intersection = (BitSet) other;
intersection.and(bitset);
return intersection.equals(bitset);
}
/**
* Splits events of a row if they overlap an island. Islands are areas between the token which are
* included in the result.
*
* @param row
* @param graph
* @param text
* @param startTokenIndex token index of the first token in the match
* @param endTokenIndex token index of the last token in the match
*/
private static void splitRowsOnIslands(
Row row,
final SDocumentGraph graph,
STextualDS text,
long startTokenIndex,
long endTokenIndex) {
BitSet tokenCoverage = new BitSet();
// get the sorted token
List<SToken> sortedTokenList = graph.getSortedTokenByText();
// add all token belonging to the right text to the bit set
ListIterator<SToken> itToken = sortedTokenList.listIterator();
while (itToken.hasNext()) {
SToken t = itToken.next();
if (text == null || text == CommonHelper.getTextualDSForNode(t, graph)) {
RelannisNodeFeature feat =
(RelannisNodeFeature) t.getFeature(ANNIS_NS, FEAT_RELANNIS_NODE).getValue();
long tokenIndexRaw = feat.getTokenIndex();
tokenIndexRaw = clip(tokenIndexRaw, startTokenIndex, endTokenIndex);
int tokenIndex = (int) (tokenIndexRaw - startTokenIndex);
tokenCoverage.set(tokenIndex);
}
}
ListIterator<GridEvent> itEvents = row.getEvents().listIterator();
while (itEvents.hasNext()) {
GridEvent event = itEvents.next();
BitSet eventBitSet = new BitSet();
eventBitSet.set(event.getLeft(), event.getRight() + 1);
// restrict event bitset on the locations where token are present
eventBitSet.and(tokenCoverage);
// if there is is any 0 bit before the right border there is a break in the event
// and we need to split it
if (eventBitSet.nextClearBit(event.getLeft()) <= event.getRight()) {
// remove the original event
row.removeEvent(itEvents);
// The event bitset now marks all the locations which the event should
// cover.
// Make a list of new events for each connected range in the bitset
int subElement = 0;
int offset = eventBitSet.nextSetBit(0);
while (offset >= 0) {
int end = eventBitSet.nextClearBit(offset) - 1;
if (offset < end) {
GridEvent newEvent = new GridEvent(event);
newEvent.setId(event.getId() + "_islandsplit_" + subElement++);
newEvent.setLeft(offset);
newEvent.setRight(end);
row.addEvent(itEvents, newEvent);
}
offset = eventBitSet.nextSetBit(end + 1);
}
} // end if we need to split
}
}
/**
* evolve the born value a single iteration by mixing in either pred or combo
*
* @param pred if combo is null, use pred.born
* @param combo if non-null, the value to mix in
* @return true if the evolution resulted in a change in the born value
*/
boolean evalBornIn(Usage pred, BitSet combo) {
BitSet old = (BitSet) born.clone();
if (combo == null) combo = pred.born;
if (firstBorn) born.or(combo);
else born.and(combo);
firstBorn = false;
return !old.equals(born);
}
public int selectBestBlockForDownload(Friend remoteFriend) throws IOException {
if (T.t) {
T.debug("Selecting best block for download. Remote: " + remoteFriend);
}
BlockMask bm = blockMasks.get(remoteFriend.getGuid());
if (bm == null) {
if (T.t) {
T.info("Ehh. Don't know anything about this friends block mask. Can't download.");
}
return -1;
}
BitSet interestingBlocks = getInterestingBlocks(bm);
// remove bocks in progress from interesting blocks:
BlockFile bf = storage.getBlockFile(root);
BitSet blocksInProgress = bf == null ? new BitSet() : bf.getBlocksInProgress();
blocksInProgress.flip(0, fd.getNumberOfBlocks());
blocksInProgress.and(interestingBlocks);
if (blocksInProgress.cardinality() > 0) {
// there are blocks of interest that are NOT in progress. Take one of these
interestingBlocks = blocksInProgress;
} // else there are only blocks in progress. Use any of them
int highestBlockNumber = 0;
if (bf != null) {
highestBlockNumber = bf.getHighestCompleteBlock();
}
highestBlockNumber += manager.getCore().getSettings().getInternal().getMaxfileexpandinblocks();
// we prefer to load blocks below highestBlockNumber
if (interestingBlocks.nextSetBit(0) < highestBlockNumber) {
// we're good - there are interesting blocks below the highest block number.
// remove all blocks above highest block number:
if (highestBlockNumber + 1 < fd.getNumberOfBlocks()) {
interestingBlocks.clear(highestBlockNumber + 1, fd.getNumberOfBlocks());
}
}
// select a random block of the ones we're interested in - change this to rarest first in the
// future
int c = interestingBlocks.cardinality();
int n = (int) (Math.random() * c);
for (int i = interestingBlocks.nextSetBit(0), j = 0;
i >= 0;
i = interestingBlocks.nextSetBit(i + 1), j++) {
if (j == n) {
return i;
}
}
if (T.t) {
T.trace("Can't find any block to download from " + remoteFriend);
}
return -1;
}
private void changeServiceDependencies(final double addFactor, final double removeFactor) {
BitSet servicesInNeighbourhood[] = new BitSet[numNeighbourhoods];
for (int s = 0; s < servicesInNeighbourhood.length; ++s) {
servicesInNeighbourhood[s] = new BitSet();
}
IntAVLTreeSet serviceToNeighbourhoods[] = new IntAVLTreeSet[services.length];
for (int s = 0; s < services.length; ++s) serviceToNeighbourhoods[s] = new IntAVLTreeSet();
for (Process p : processes) {
int n = machines[assignment[p.id]].neighborhood;
int s = p.service;
servicesInNeighbourhood[n].set(s);
serviceToNeighbourhoods[s].add(n);
}
for (int sid = 0; sid < services.length; sid++) {
IntAVLTreeSet neighbourhoods = serviceToNeighbourhoods[sid];
BitSet intersection = null;
for (int n : neighbourhoods) {
if (intersection == null) {
intersection = new BitSet();
intersection.or(servicesInNeighbourhood[n]);
} else intersection.and(servicesInNeighbourhood[n]);
}
// intersection - all possible services I can depend on
for (int d : services[sid].dependencies) intersection.clear(d);
intersection.clear(sid); // exclude itself
// services we can add as new dependencies
int[] list = new int[intersection.cardinality()];
int i = 0;
for (int q = intersection.nextSetBit(0); q >= 0; q = intersection.nextSetBit(q + 1)) {
list[i++] = q;
}
MyArrayUtils.shuffle(list, random);
int addCount = nextInt(0, 1 + (int) (addFactor * services[sid].dependencies.length));
// addCount = 0;
int removeCount = nextInt(0, 1 + (int) (addFactor * services[sid].dependencies.length));
int[] newdependencies =
org.apache.commons.lang.ArrayUtils.addAll(
services[sid].dependencies,
Arrays.copyOfRange(list, 0, Math.min(list.length, addCount)));
MyArrayUtils.shuffle(newdependencies, random);
services[sid].dependencies =
Arrays.copyOfRange(newdependencies, 0, Math.max(0, newdependencies.length - removeCount));
}
}
public void testItShouldNotFullyIntersectTheFingerprintDerivedFromASubstructure() {
BitSet benzene = fingerprinter.getFingerprint(Molecules.createBenzene());
BitSet phenol = fingerprinter.getFingerprint(Molecules.createPhenol());
BitSet intersection = (BitSet) phenol.clone();
intersection.and(benzene);
assertFalse(match(phenol, benzene));
}
/**
* Given the current set of potential matching rules, obtain the rules which match the current
* field defined either by key or anykey. The rules are represented by bitsets which are
* intersected to return the remain potentially matching rules. If after bitset intersection, the
* resulting bitset is empty, an exception is thrown to halt the search.
*
* @param src - the current set of potentially matching rules.
* @param map - the data structure holding all the possible values defined by all flow space rules
* for given field.
* @param key - the key (or field value) used to index the data structure.
* @param anykey - the 'any' value for this field.
* @param wildcards - the set of wildcards defined by this match
* @param wild - the specific wildcard value for this field
* @return - true if field was wildcarded and false otherwise.
* @throws NoMatch - if the set of rules (ie. the src bitset) is empty after intersection.
*/
private <K> boolean testEmpty(
BitSet src, Map<K, BitSet> map, K key, K anykey, int wildcards, int wild) throws NoMatch {
if ((wildcards & wild) != 0) return true;
BitSet any = get(map, anykey);
any.or(get(map, key));
src.and(any);
if (src.isEmpty()) throw new NoMatch("No Match");
return false;
}
public synchronized void commit() {
Object[] o = observers.toArray();
for (int i = 0; i < o.length; i++) {
BitSet tmp = (BitSet) changeMap.clone();
ObserverEntry oe = (ObserverEntry) o[i];
tmp.and(oe.ids);
if (tmp.length() != 0) oe.observer.update(this, oe.tag);
}
}
Coverage getCoveredBasicBlocks() {
BitSet bExec = getExecutedInsn();
BitSet bb = getBasicBlocks();
int nCov = 0;
if (excludeHandlers) {
BitSet handlers = getHandlers();
bb.and(handlers);
}
if (bExec != null) {
BitSet bCov = new BitSet(bb.size());
bCov.or(bb);
bCov.and(bExec);
nCov = bCov.cardinality();
}
return new Coverage(bb.cardinality(), nCov);
}
/** Change this SprayPattern to be (this & p), only 1s both places survive. */
public SprayPattern and(SprayPattern p) {
if (size != p.size) throw new IndexOutOfBoundsException();
if (is(false)) ; // No change
else if (is(true)) set(p);
else if (p.is(false)) set(false);
else if (p.is(true)) ; // No change
else {
array.and(p.array);
update();
}
return this;
}
private BitSet getInterestingBlocks(BlockMask remote) throws IOException {
if (T.t) {
T.ass(fd != null, "Need a FD for this call to work");
}
BitSet interestingBlocks = new BitSet();
BlockMask myBm = manager.getCore().getFileManager().getBlockMask(fd.getRootHash());
if (myBm != null) {
interestingBlocks.or(myBm);
}
interestingBlocks.flip(0, fd.getNumberOfBlocks());
interestingBlocks.and(remote);
return interestingBlocks;
}
@SuppressWarnings("null")
@Test
public void flipTestBigA() {
final int numCases = 1000000;
System.out.println("flipTestBigA for " + numCases + " tests");
final BitSet bs = new BitSet();
final Random r = new Random(3333);
int checkTime = 2;
RoaringBitmap rb1 = new RoaringBitmap(), rb2 = null; // alternate
// between
// them
for (int i = 0; i < numCases; ++i) {
final int start = r.nextInt(65536 * 20);
int end = r.nextInt(65536 * 20);
if (r.nextDouble() < 0.1) end = start + r.nextInt(100);
if ((i & 1) == 0) {
rb2 = RoaringBitmap.flip(rb1, start, end);
// tweak the other, catch bad sharing
rb1.flip(r.nextInt(65536 * 20), r.nextInt(65536 * 20));
} else {
rb1 = RoaringBitmap.flip(rb2, start, end);
rb2.flip(r.nextInt(65536 * 20), r.nextInt(65536 * 20));
}
if (start < end) bs.flip(start, end); // throws exception
// otherwise
// insert some more ANDs to keep things sparser
if (r.nextDouble() < 0.2 && (i & 1) == 0) {
final RoaringBitmap mask = new RoaringBitmap();
final BitSet mask1 = new BitSet();
final int startM = r.nextInt(65536 * 20);
final int endM = startM + 100000;
mask.flip(startM, endM);
mask1.flip(startM, endM);
mask.flip(0, 65536 * 20 + 100000);
mask1.flip(0, 65536 * 20 + 100000);
rb2.and(mask);
bs.and(mask1);
}
if (i > checkTime) {
System.out.println("check after " + i + ", card = " + rb2.getCardinality());
final RoaringBitmap rb = (i & 1) == 0 ? rb2 : rb1;
final boolean status = equals(bs, rb);
Assert.assertTrue(status);
checkTime *= 1.5;
}
}
}
private BlockDataFlowState generateDFState(CFGBlock block) {
int totalGlobals = this.uniqueGlobals.get(block.getMethodName()).size();
// Get the original inBitSet for this block
BitSet origIn;
if (this.cfgBlocksState.containsKey(block)) {
origIn = this.cfgBlocksState.get(block).getIn();
} else {
origIn = new BitSet(totalGlobals);
origIn.set(0, totalGlobals);
}
// Calculate the in BitSet by taking intersection of predecessors
BlockDataFlowState bFlow = new BlockDataFlowState(totalGlobals);
// If there exist at least one successor, set Out to all True
if (block.getSuccessors().size() > 0) {
bFlow.getOut().set(0, totalGlobals);
}
BitSet out = bFlow.getOut();
for (CFGBlock pred : block.getSuccessors()) {
if (this.cfgBlocksState.containsKey(pred)) {
out.and(this.cfgBlocksState.get(pred).getIn());
}
}
calculateGenKillSets(block, bFlow);
// Calculate Out
BitSet in = bFlow.getIn(); // IN = (OUT - KILL) U GEN
in.or(out);
in.xor(bFlow.getKill());
in.or(bFlow.getGen());
if (!in.equals(origIn)) {
// Add successors to cfgBlocks list
for (CFGBlock pred : block.getPredecessors()) {
if (!cfgBlocksToProcess.contains(pred)) {
cfgBlocksToProcess.add(pred);
}
}
}
// Remove this block, since it has been processed
cfgBlocksToProcess.remove(block);
return bFlow;
}
BitSet singleBitDiff(BitSet x, BitSet y) {
BitSet t = new BitSet(x.length());
t.or(x);
t.flip(0, t.size());
t.and(y);
switch (t.cardinality()) {
case 0:
return t;
case 1:
return t;
default:
return new BitSet();
}
}
BitSet addClause(BooleanQuery bq, BitSet result) {
final BitSet rnd = sets[r.nextInt(sets.length)];
Query q =
new ConstantScoreQuery(
new Filter() {
@Override
public DocIdSet getDocIdSet(IndexReader reader) {
return new DocIdBitSet(rnd);
};
});
bq.add(q, BooleanClause.Occur.MUST);
if (validate) {
if (result == null) result = (BitSet) rnd.clone();
else result.and(rnd);
}
return result;
}
public BitSet getCharContainingIndexSet(char[] nameChars) {
BitSet sets = new BitSet(sources.size());
sets.set(0, sources.size());
for (char c : nameChars) {
c = Character.toLowerCase(c);
BitSet charSet = index.get(c);
if (charSet == null) {
sets.clear();
break;
} else {
sets.and(charSet);
if (sets.isEmpty()) {
break;
}
}
}
return sets;
}
protected Set<HierNode<T>> gcs(Set<HierNode<T>> set) {
Set<HierNode<T>> s = new HashSet<HierNode<T>>();
Iterator<HierNode<T>> iter = set.iterator();
BitSet a = new BitSet(this.size());
a.or(iter.next().getBitMask());
while (iter.hasNext()) {
a.and(iter.next().getBitMask());
}
// System.out.println( "Root mask for ceil " + toBinaryString( a ) );
for (HierNode<T> node : getNodes()) {
if (superset(node.getBitMask(), a) >= 0) {
s.add(node);
}
}
Set<HierNode<T>> cl = ceil(s);
return cl;
}
private BitSet getCode(Object value, CodedHierarchy x) {
if (value instanceof Class) {
String typeName = ((Class) value).getName();
return x.getCode(typeName);
} else if (value instanceof String) {
return x.getCode(value);
} else if (value instanceof Collection) {
BitSet code = null;
for (Object o : ((Collection) value)) {
if (code == null) {
code = (BitSet) getCode(o, x).clone();
} else {
code.and(getCode(o, x));
}
}
return code;
}
throw new UnsupportedOperationException(" IsA Operator : Unsupported literal " + value);
}
@Test
public void flipTestBig() {
final int numCases = 1000000;
System.out.println("flipTestBig for " + numCases + " tests");
final RoaringBitmap rb = new RoaringBitmap();
final BitSet bs = new BitSet();
final Random r = new Random(3333);
int checkTime = 2;
for (int i = 0; i < numCases; ++i) {
final int start = r.nextInt(65536 * 20);
int end = r.nextInt(65536 * 20);
if (r.nextDouble() < 0.1) end = start + r.nextInt(100);
rb.flip(start, end);
if (start < end) bs.flip(start, end); // throws exception
// otherwise
// insert some more ANDs to keep things sparser
if (r.nextDouble() < 0.2) {
final RoaringBitmap mask = new RoaringBitmap();
final BitSet mask1 = new BitSet();
final int startM = r.nextInt(65536 * 20);
final int endM = startM + 100000;
mask.flip(startM, endM);
mask1.flip(startM, endM);
mask.flip(0, 65536 * 20 + 100000);
mask1.flip(0, 65536 * 20 + 100000);
rb.and(mask);
bs.and(mask1);
}
// see if we can detect incorrectly shared containers
if (r.nextDouble() < 0.1) {
final RoaringBitmap irrelevant = RoaringBitmap.flip(rb, 10, 100000);
irrelevant.flip(5, 200000);
irrelevant.flip(190000, 260000);
}
if (i > checkTime) {
System.out.println("check after " + i + ", card = " + rb.getCardinality());
Assert.assertTrue(equals(bs, rb));
checkTime *= 1.5;
}
}
}
public BitSet bits(IndexReader reader) throws IOException {
// Iterate through list of filters and apply the boolean AND operation
// on each bitSet. The AND operator has the affect that only documents
// that are allowed by every single filter in the filter list will be
// allowed by this MultiFilter.
int filterListSize = filterList.size();
if (filterListSize > 0) {
BitSet bits = ((Filter) filterList.get(0)).bits(reader);
for (int i = 1; i < filterListSize; i++) {
bits.and(((Filter) filterList.get(i)).bits(reader));
}
return bits;
}
// There are no filters defined. In this case, we return a new
// BitSet that will filter out all documents. This is probably the most
// consistent behavior with the Lucene API. It's also a lot more
// efficient considering the BitSet implementation.
else {
return new BitSet(reader.maxDoc());
}
}
/**
* Create a new bitmap by performing the I-STEP with this bitmap and the bitmap of an item.
*
* @param bitmapItem the bitmap of the item
* @param sequencesSize the sequence lengths
* @param lastBitIndex the last bit index
* @return the new bitmap
*/
Bitmap createNewBitmapIStep(Bitmap bitmapItem, List<Integer> sequencesSize, int lastBitIndex) {
// INTERSECTION_COUNT++;
// We create the new bitmap
BitSet newBitset = new BitSet(lastBitIndex); // TODO: USE LAST SET BIT
Bitmap newBitmap = new Bitmap(newBitset);
// We do an AND with the bitmap of the item
for (int bit = bitmap.nextSetBit(0); bit >= 0; bit = bitmap.nextSetBit(bit + 1)) {
if (bitmapItem.bitmap.get(bit)) { // if both bits are TRUE
// set the bit
newBitmap.bitmap.set(bit);
// update the support
int sid = bitToSID(bit, sequencesSize);
if (sid != newBitmap.lastSID) {
newBitmap.sidsum += sid;
newBitmap.support++;
}
newBitmap.lastSID = sid; // remember the last SID
// new
int tid = bit - sequencesSize.get(sid);
if (firstItemsetID == -1 || tid < firstItemsetID) {
firstItemsetID = tid;
}
// end new
}
}
// Then do the AND
newBitset.and(bitmapItem.bitmap);
// We return the resulting bitmap
return newBitmap;
}
/* (non-Javadoc)
* @see java.util.BitSet#and(java.util.BitSet)
*/
public void and(java.util.BitSet set) {
super.and(set);
makeDirty();
}
/**
* The writeReplace method is called when ObjectOutputStream is preparing to write the object to
* the stream. The ObjectOutputStream checks whether the class defines the writeReplace method. If
* the method is defined, the writeReplace method is called to allow the object to designate its
* replacement in the stream. The object returned should be either of the same type as the object
* passed in or an object that when read and resolved will result in an object of a type that is
* compatible with all references to the object.
*
* @return the replaced object
* @throws ObjectStreamException
*/
protected Object writeReplace() throws ObjectStreamException {
java.util.BitSet copy = new java.util.BitSet();
copy.and(this);
return copy;
}
/**
* Set an identifier to analyze. Afterwards, call methods like getScripts()
*
* @param identifier the identifier to analyze
* @return self
* @internal
* @deprecated This API is ICU internal only.
*/
@Deprecated
public IdentifierInfo setIdentifier(String identifier) {
this.identifier = identifier;
clear();
BitSet scriptsForCP = new BitSet();
int cp;
for (int i = 0; i < identifier.length(); i += Character.charCount(i)) {
cp = Character.codePointAt(identifier, i);
// Store a representative character for each kind of decimal digit
if (UCharacter.getType(cp) == UCharacterCategory.DECIMAL_DIGIT_NUMBER) {
// Just store the zero character as a representative for comparison. Unicode guarantees it
// is cp - value
numerics.add(cp - UCharacter.getNumericValue(cp));
}
UScript.getScriptExtensions(cp, scriptsForCP);
scriptsForCP.clear(UScript.COMMON);
scriptsForCP.clear(UScript.INHERITED);
// if (temp.cardinality() == 0) {
// // HACK for older version of ICU
// requiredScripts.set(UScript.getScript(cp));
// } else
switch (scriptsForCP.cardinality()) {
case 0:
break;
case 1:
// Single script, record it.
requiredScripts.or(scriptsForCP);
break;
default:
if (!requiredScripts.intersects(scriptsForCP) && scriptSetSet.add(scriptsForCP)) {
scriptsForCP = new BitSet();
}
break;
}
}
// Now make a final pass through to remove alternates that came before singles.
// [Kana], [Kana Hira] => [Kana]
// This is relatively infrequent, so doesn't have to be optimized.
// We also compute any commonalities among the alternates.
if (scriptSetSet.size() > 0) {
commonAmongAlternates.set(0, UScript.CODE_LIMIT);
for (Iterator<BitSet> it = scriptSetSet.iterator(); it.hasNext(); ) {
final BitSet next = it.next();
// [Kana], [Kana Hira] => [Kana]
if (requiredScripts.intersects(next)) {
it.remove();
} else {
// [[Arab Syrc Thaa]; [Arab Syrc]] => [[Arab Syrc]]
commonAmongAlternates.and(next); // get the intersection.
for (BitSet other : scriptSetSet) {
if (next != other && contains(next, other)) {
it.remove();
break;
}
}
}
}
}
if (scriptSetSet.size() == 0) {
commonAmongAlternates.clear();
}
return this;
}