public int doNestedTermConjunctions( IndexSearcher s, int termsInIndex, int maxOuterClauses, int maxClauses, int iter) throws IOException { int ret = 0; long nMatches = 0; for (int i = 0; i < iter; i++) { int oClauses = r.nextInt(maxOuterClauses - 1) + 2; BooleanQuery oq = new BooleanQuery(); for (int o = 0; o < oClauses; o++) { int nClauses = r.nextInt(maxClauses - 1) + 2; // min 2 clauses BooleanQuery bq = new BooleanQuery(); BitSet termflag = new BitSet(termsInIndex); for (int j = 0; j < nClauses; j++) { int tnum; // don't pick same clause twice tnum = r.nextInt(termsInIndex); if (termflag.get(tnum)) tnum = termflag.nextClearBit(tnum); if (tnum < 0 || tnum >= 25) tnum = termflag.nextClearBit(0); termflag.set(tnum); Query tq = new TermQuery(terms[tnum]); bq.add(tq, BooleanClause.Occur.MUST); } // inner oq.add(bq, BooleanClause.Occur.MUST); } // outer CountingHitCollector hc = new CountingHitCollector(); s.search(oq, hc); nMatches += hc.getCount(); ret += hc.getSum(); } System.out.println("Average number of matches=" + (nMatches / iter)); return ret; }
private void assignConnectorPolicy(ActivityCluster ac, Map<ActivityId, ActivityPlan> taskMap) { Map<ConnectorDescriptorId, IConnectorPolicy> cPolicyMap = new HashMap<ConnectorDescriptorId, IConnectorPolicy>(); Set<ActivityId> activities = ac.getActivityMap().keySet(); BitSet targetBitmap = new BitSet(); for (ActivityId a1 : activities) { Task[] ac1TaskStates = taskMap.get(a1).getTasks(); int nProducers = ac1TaskStates.length; List<IConnectorDescriptor> outputConns = ac.getActivityOutputMap().get(a1); if (outputConns != null) { for (IConnectorDescriptor c : outputConns) { ConnectorDescriptorId cdId = c.getConnectorId(); ActivityId a2 = ac.getConsumerActivity(cdId); Task[] ac2TaskStates = taskMap.get(a2).getTasks(); int nConsumers = ac2TaskStates.length; int[] fanouts = new int[nProducers]; if (c.allProducersToAllConsumers()) { for (int i = 0; i < nProducers; ++i) { fanouts[i] = nConsumers; } } else { for (int i = 0; i < nProducers; ++i) { c.indicateTargetPartitions(nProducers, nConsumers, i, targetBitmap); fanouts[i] = targetBitmap.cardinality(); } } IConnectorPolicy cp = assignConnectorPolicy(ac, c, nProducers, nConsumers, fanouts); cPolicyMap.put(cdId, cp); } } } scheduler.getJobRun().getConnectorPolicyMap().putAll(cPolicyMap); }
@Override protected void verifyContentAcceptance( EventSequence alpha, ItemSet set, Vector<Element> alphabet, int[] sup, ProjectedDB[] projDBs, int indProj, int sInd, int eInd, boolean inParallel, BitSet visited, BitSet accepted) { for (int i = 0; i < set.size(); i++) { Element el = set.elementAt(i); int found = alphabet.indexOf(el); if ((-1 != found)) { if (!visited.get(found)) { visited.set(found); accepted.set(found, isAcceptedByRelaxation(alpha, el, inParallel)); } if (accepted.get(found)) { if (!projDBs[found].contains(sInd)) sup[found]++; projDBs[found].set(sInd, eInd); } } } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, StorageResourceDescription struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeString(struct.storageResourceId); oprot.writeString(struct.hostName); BitSet optionals = new BitSet(); if (struct.isSetStorageResourceDescription()) { optionals.set(0); } if (struct.isSetEnabled()) { optionals.set(1); } if (struct.isSetDataMovementInterfaces()) { optionals.set(2); } oprot.writeBitSet(optionals, 3); if (struct.isSetStorageResourceDescription()) { oprot.writeString(struct.storageResourceDescription); } if (struct.isSetEnabled()) { oprot.writeBool(struct.enabled); } if (struct.isSetDataMovementInterfaces()) { { oprot.writeI32(struct.dataMovementInterfaces.size()); for (org.apache.airavata.model.data.movement.DataMovementInterface _iter4 : struct.dataMovementInterfaces) { _iter4.write(oprot); } } } }
private void buildSCC() { digraph.removeNode(n2); digraph.removeNode(n2 + 1); digraph.addNode(n2); digraph.addNode(n2 + 1); // TODO CHECK THIS PART for (int i = 0; i < n; i++) { if (free.get(i)) { digraph.addArc(n2, i); } else { digraph.addArc(i, n2); } } for (int i = n; i < n2; i++) { if (free.get(i)) { digraph.addArc(i, n2 + 1); } else { digraph.addArc(n2 + 1, i); } } SCCfinder.findAllSCC(); nodeSCC = SCCfinder.getNodesSCC(); digraph.removeNode(n2); digraph.removeNode(n2 + 1); }
/** * Returns an exact copy of the game. This may be used for forward searches such as minimax. The * copying is relatively efficient. * * @return the game */ public Game copy() { Game copy = new Game(); copy.seed = seed; copy.rnd = new Random(seed); copy.laberintoActua = laberintoActua; copy.pills = (BitSet) pills.clone(); copy.powerPills = (BitSet) powerPills.clone(); copy.indiceDeLaberinto = indiceDeLaberinto; copy.cuentaElLvl = cuentaElLvl; copy.tiempoLvlActual = tiempoLvlActual; copy.tiempoTotal = tiempoTotal; copy.score = score; copy.fastamasComerMultiplicador = fastamasComerMultiplicador; copy.juegoTerminado = juegoTerminado; copy.timeOfLastGlobalReversal = timeOfLastGlobalReversal; copy.pacmanFueComido = pacmanFueComido; copy.pastillaFueComida = pastillaFueComida; copy.pildoraPoderFueComida = pildoraPoderFueComida; copy.pacman = pacman.copy(); copy.fantasmaComido = new EnumMap<GHOST, Boolean>(GHOST.class); copy.fantasmas = new EnumMap<GHOST, Ghost>(GHOST.class); for (GHOST ghostType : GHOST.values()) { copy.fantasmas.put(ghostType, fantasmas.get(ghostType).copy()); copy.fantasmaComido.put(ghostType, fantasmaComido.get(ghostType)); } return copy; }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, LineageCommand struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { struct.commandType = tachyon.thrift.CommandType.findByValue(iprot.readI32()); struct.setCommandTypeIsSet(true); } if (incoming.get(1)) { { org.apache.thrift.protocol.TList _list13 = new org.apache.thrift.protocol.TList( org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); struct.checkpointFiles = new ArrayList<CheckpointFile>(_list13.size); CheckpointFile _elem14; for (int _i15 = 0; _i15 < _list13.size; ++_i15) { _elem14 = new CheckpointFile(); _elem14.read(iprot); struct.checkpointFiles.add(_elem14); } } struct.setCheckpointFilesIsSet(true); } }
public zziz zzgX() { int i = 0; int ai[] = null; if (zzGu != null) { int ai1[] = new int[zzGu.cardinality()]; int j = zzGu.nextSetBit(0); do { ai = ai1; if (j < 0) { break; } ai1[i] = j; j = zzGu.nextSetBit(j + 1); i++; } while (true); } return new zziz( mName, zzGo, zzGp, zzGq, zzGr, zzGs, (zzit[]) zzGt.toArray(new zzit[zzGt.size()]), ai, zzGv); }
@Override public void visitCode(Code obj) { Method m = getMethod(); if (m.getReturnType() == Type.VOID) { return; } stack.resetForMethodEntry(this); ifBlocks.clear(); activeUnconditional = null; CodeException[] ces = obj.getExceptionTable(); if (CollectionUtils.isEmpty(ces)) { catchPCs = null; } else { catchPCs = new BitSet(); for (CodeException ce : ces) { catchPCs.set(ce.getHandlerPC()); } } gotoBranchPCs.clear(); casePositions.clear(); lookingForResetOp = false; try { super.visitCode(obj); } catch (StopOpcodeParsingException e) { // reported an issue, so get out } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, TGetOperationStatusResp struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; struct.status.write(oprot); BitSet optionals = new BitSet(); if (struct.isSetOperationState()) { optionals.set(0); } if (struct.isSetSqlState()) { optionals.set(1); } if (struct.isSetErrorCode()) { optionals.set(2); } if (struct.isSetErrorMessage()) { optionals.set(3); } oprot.writeBitSet(optionals, 4); if (struct.isSetOperationState()) { oprot.writeI32(struct.operationState.getValue()); } if (struct.isSetSqlState()) { oprot.writeString(struct.sqlState); } if (struct.isSetErrorCode()) { oprot.writeI32(struct.errorCode); } if (struct.isSetErrorMessage()) { oprot.writeString(struct.errorMessage); } }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, TGetOperationStatusResp struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; struct.status = new TStatus(); struct.status.read(iprot); struct.setStatusIsSet(true); BitSet incoming = iprot.readBitSet(4); if (incoming.get(0)) { struct.operationState = org.apache.hive.service.cli.thrift.TOperationState.findByValue(iprot.readI32()); struct.setOperationStateIsSet(true); } if (incoming.get(1)) { struct.sqlState = iprot.readString(); struct.setSqlStateIsSet(true); } if (incoming.get(2)) { struct.errorCode = iprot.readI32(); struct.setErrorCodeIsSet(true); } if (incoming.get(3)) { struct.errorMessage = iprot.readString(); struct.setErrorMessageIsSet(true); } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, MemoryUsage struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetMax()) { optionals.set(0); } if (struct.isSetTotal()) { optionals.set(1); } if (struct.isSetFree()) { optionals.set(2); } oprot.writeBitSet(optionals, 3); if (struct.isSetMax()) { oprot.writeI64(struct.max); } if (struct.isSetTotal()) { oprot.writeI64(struct.total); } if (struct.isSetFree()) { oprot.writeI64(struct.free); } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, BankGroupThrift struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetId()) { optionals.set(0); } if (struct.isSetGroupType()) { optionals.set(1); } if (struct.isSetBankId()) { optionals.set(2); } if (struct.isSetBankCode()) { optionals.set(3); } oprot.writeBitSet(optionals, 4); if (struct.isSetId()) { oprot.writeI32(struct.id); } if (struct.isSetGroupType()) { oprot.writeI32(struct.groupType); } if (struct.isSetBankId()) { oprot.writeI32(struct.bankId); } if (struct.isSetBankCode()) { oprot.writeString(struct.bankCode); } }
public BitSet randBitSet(int sz, int numBitsToSet) { BitSet set = new BitSet(sz); for (int i = 0; i < numBitsToSet; i++) { set.set(r.nextInt(sz)); } return set; }
/** * Faster removal of components from a entity. * * @param type the type of component to remove from this entity * @return this EntityEdit for chaining */ public EntityEdit remove(ComponentType type) { if (componentBits.get(type.getIndex())) { world.getComponentManager().removeComponent(entity, type); componentBits.clear(type.getIndex()); } return this; }
/** * Updates the interal bitset from <code>iterator</code>. This will set <code>validMask</code> to * true if <code>iterator</code> is non-null. */ private void updateMask(AttributedCharacterIterator iterator) { if (iterator != null) { validMask = true; this.iterator = iterator; // Update the literal mask if (literalMask == null) { literalMask = new BitSet(); } else { for (int counter = literalMask.length() - 1; counter >= 0; counter--) { literalMask.clear(counter); } } iterator.first(); while (iterator.current() != CharacterIterator.DONE) { Map attributes = iterator.getAttributes(); boolean set = isLiteral(attributes); int start = iterator.getIndex(); int end = iterator.getRunLimit(); while (start < end) { if (set) { literalMask.set(start); } else { literalMask.clear(start); } start++; } iterator.setIndex(start); } } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, AppInfoResult struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetDeviceId()) { optionals.set(0); } if (struct.isSetFlowNum()) { optionals.set(1); } if (struct.isSetResult()) { optionals.set(2); } if (struct.isSetAppdatainfo()) { optionals.set(3); } oprot.writeBitSet(optionals, 4); if (struct.isSetDeviceId()) { oprot.writeI32(struct.deviceId); } if (struct.isSetFlowNum()) { oprot.writeI32(struct.flowNum); } if (struct.isSetResult()) { oprot.writeBool(struct.result); } if (struct.isSetAppdatainfo()) { struct.appdatainfo.write(oprot); } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, ResourceJobManager struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; oprot.writeString(struct.resourceJobManagerId); oprot.writeI32(struct.resourceJobManagerType.getValue()); BitSet optionals = new BitSet(); if (struct.isSetPushMonitoringEndpoint()) { optionals.set(0); } if (struct.isSetJobManagerBinPath()) { optionals.set(1); } if (struct.isSetJobManagerCommands()) { optionals.set(2); } oprot.writeBitSet(optionals, 3); if (struct.isSetPushMonitoringEndpoint()) { oprot.writeString(struct.pushMonitoringEndpoint); } if (struct.isSetJobManagerBinPath()) { oprot.writeString(struct.jobManagerBinPath); } if (struct.isSetJobManagerCommands()) { { oprot.writeI32(struct.jobManagerCommands.size()); for (Map.Entry<JobManagerCommand, String> _iter5 : struct.jobManagerCommands.entrySet()) { oprot.writeI32(_iter5.getKey().getValue()); oprot.writeString(_iter5.getValue()); } } } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, Result struct) throws org.apache.thrift.TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetValue()) { optionals.set(0); } if (struct.isSetError()) { optionals.set(1); } if (struct.isSetErrortext()) { optionals.set(2); } oprot.writeBitSet(optionals, 3); if (struct.isSetValue()) { oprot.writeString(struct.value); } if (struct.isSetError()) { oprot.writeI32(struct.error.getValue()); } if (struct.isSetErrortext()) { oprot.writeString(struct.errortext); } }
private void testConsistency() { // test if there's an entry for every set bit in availabilityMap for (int i = availabilityMap.nextSetBit(0); i >= 0; i = availabilityMap.nextSetBit(i + 1)) { if (iBlockRegistry.getRaw(i) == null && iItemRegistry.getRaw(i) == null && !blockedIds.contains(i)) { throw new IllegalStateException( String.format("availabilityMap references empty entries for id %d.", i)); } } for (int pass = 0; pass < 2; pass++) { boolean isBlock = pass == 0; String type = isBlock ? "block" : "item"; FMLControlledNamespacedRegistry<?> registry = isBlock ? iBlockRegistry : iItemRegistry; registry.validateContent( (isBlock ? MAX_BLOCK_ID : MAX_ITEM_ID), type, availabilityMap, blockedIds, iBlockRegistry); } FMLLog.fine("Registry consistency check successful"); }
/** * Transition to the next generation by applying the Conway's Game Of Life rule. * * <ol> * <li>Any live cell with fewer than two live neighbours dies, as if caused by under-population. * <li>Any live cell with two or three live neighbours lives on to the next generation. * <li>Any live cell with more than three live neighbours dies, as if by overcrowding. * <li>Any dead cell with exactly three live neighbours becomes a live cell, as if by * reproduction. * </ol> */ public void nextGeneration() { // At each step time, looping all cells in the current generation to apply the rules for (int i = 0; i < vertical; i++) { for (int j = 0; j < horizontal; j++) { byte liveCellNeighbours = countLiveNeighbourCells(i, j); // If the cell is dead and have exactly 3 live cells neighbours becomes a live cell if (!currentGeneration.get(getIndex(i, j))) { if (liveCellNeighbours == 3) { tempGeneration.set(getIndex(i, j)); } } else { // If the cell is live cell // If live cell with fewer than two live neighbours dies // If live cell with more than three live neighbours dies, as if by overcrowding. if (liveCellNeighbours < 2 || liveCellNeighbours > 3) { tempGeneration.clear(getIndex(i, j)); } else { // Otherwise, keep the current state of the cell tempGeneration.set(getIndex(i, j), currentGeneration.get(getIndex(i, j))); } } } } // Swap the next generation to the current generation for the next step time BitSet bs = currentGeneration; currentGeneration = tempGeneration; tempGeneration = bs; }
@Override public void setProperty(String propertyName, Object value, BitSet bsSelected) { // if (Logger.debugging) { // Logger.debug("Hover.setProperty(" + propertyName + "," + value + ")"); // } if ("target" == propertyName) { if (value == null) atomIndex = -1; else { atomIndex = ((Integer) value).intValue(); } return; } if ("text" == propertyName) { text = (String) value; if (text != null && text.length() == 0) text = null; return; } if ("specialLabel" == propertyName) { specialLabel = (String) value; return; } if ("atomLabel" == propertyName) { String text = (String) value; if (text != null && text.length() == 0) text = null; int count = viewer.getAtomCount(); if (atomFormats == null || atomFormats.length < count) atomFormats = new String[count]; for (int i = bsSelected.nextSetBit(0); i >= 0; i = bsSelected.nextSetBit(i + 1)) atomFormats[i] = text; return; } if ("xy" == propertyName) { xy = (Point3i) value; return; } if ("label" == propertyName) { labelFormat = (String) value; if (labelFormat != null && labelFormat.length() == 0) labelFormat = null; return; } if (propertyName == "deleteModelAtoms") { if (atomFormats != null) { int firstAtomDeleted = ((int[]) ((Object[]) value)[2])[1]; int nAtomsDeleted = ((int[]) ((Object[]) value)[2])[2]; atomFormats = (String[]) ArrayUtil.deleteElements(atomFormats, firstAtomDeleted, nAtomsDeleted); } atomIndex = -1; return; } super.setProperty(propertyName, value, null); }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, StorageResourceDescription struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; struct.storageResourceId = iprot.readString(); struct.setStorageResourceIdIsSet(true); struct.hostName = iprot.readString(); struct.setHostNameIsSet(true); BitSet incoming = iprot.readBitSet(3); if (incoming.get(0)) { struct.storageResourceDescription = iprot.readString(); struct.setStorageResourceDescriptionIsSet(true); } if (incoming.get(1)) { struct.enabled = iprot.readBool(); struct.setEnabledIsSet(true); } if (incoming.get(2)) { { org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList( org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); struct.dataMovementInterfaces = new ArrayList<org.apache.airavata.model.data.movement.DataMovementInterface>( _list5.size); org.apache.airavata.model.data.movement.DataMovementInterface _elem6; for (int _i7 = 0; _i7 < _list5.size; ++_i7) { _elem6 = new org.apache.airavata.model.data.movement.DataMovementInterface(); _elem6.read(iprot); struct.dataMovementInterfaces.add(_elem6); } } struct.setDataMovementInterfacesIsSet(true); } }
@Override public void write(org.apache.thrift.protocol.TProtocol prot, Response struct) throws TException { TTupleProtocol oprot = (TTupleProtocol) prot; BitSet optionals = new BitSet(); if (struct.isSetResultType()) { optionals.set(0); } if (struct.isSetResult()) { optionals.set(1); } if (struct.isSetOperationId()) { optionals.set(2); } oprot.writeBitSet(optionals, 3); if (struct.isSetResultType()) { oprot.writeString(struct.ResultType); } if (struct.isSetResult()) { oprot.writeBinary(struct.Result); } if (struct.isSetOperationId()) { oprot.writeString(struct.OperationId); } }
@Override public void propagate(int evtmask) throws ContradictionException { if (PropagatorEventType.isFullPropagation(evtmask)) { if (n2 < n + vars[n].getLB()) { fails(); // TODO: could be more precise, for explanation purpose } buildDigraph(); } digraph.removeNode(n2); digraph.removeNode(n2 + 1); free.clear(); for (int i = 0; i < n; i++) { if (digraph.getPredOf(i).size() == 0) { free.set(i); } } for (int i = n; i < n2; i++) { if (digraph.getSuccOf(i).size() == 0) { free.set(i); } } int card = repairMatching(); vars[n].updateUpperBound(card, this); if (vars[n].getLB() == card) { filter(); } for (int i = 0; i < idms.length; i++) { idms[i].unfreeze(); } }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, SelectQuery struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; BitSet incoming = iprot.readBitSet(2); if (incoming.get(0)) { { org.apache.thrift.protocol.TList _list21 = new org.apache.thrift.protocol.TList( org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); struct.operations = new ArrayList<SelectOperation>(_list21.size); for (int _i22 = 0; _i22 < _list21.size; ++_i22) { SelectOperation _elem23; // required _elem23 = new SelectOperation(); _elem23.read(iprot); struct.operations.add(_elem23); } } struct.setOperationsIsSet(true); } if (incoming.get(1)) { struct.page = new Page(); struct.page.read(iprot); struct.setPageIsSet(true); } }
void computeIn(LinkedList<Vertex> worklist) { int i; BitSet old; BitSet ne; Vertex v; ListIterator<Vertex> iter; iter = succ.listIterator(); while (iter.hasNext()) { v = iter.next(); out.or(v.in); } old = in; in = new BitSet(); in.or(out); in.andNot(def); in.or(use); if (!in.equals(old)) { iter = pred.listIterator(); while (iter.hasNext()) { v = iter.next(); if (!v.listed) { worklist.addLast(v); v.listed = true; } } } }
public static String encodeURI(String url, String env) throws UnsupportedEncodingException { BitSet urlsafe = new BitSet(); // alpha characters for (int i = 'a'; i <= 'z'; i++) { urlsafe.set(i); } for (int i = 'A'; i <= 'Z'; i++) { urlsafe.set(i); } // numeric characters for (int i = '0'; i <= '9'; i++) { urlsafe.set(i); } // special chars urlsafe.set('-'); urlsafe.set('_'); urlsafe.set('.'); urlsafe.set('*'); // blank to be replaced with + urlsafe.set(' '); urlsafe.set(':'); urlsafe.set('/'); urlsafe.set('='); urlsafe.set('#'); urlsafe.set('?'); urlsafe.set('&'); urlsafe.set('%'); return new String(URLCodec.encodeUrl(urlsafe, url.getBytes(env))); }
/** * @param ev * @param alphabet * @param bs * @param sup * @param seqDB * @param posDB * @param sInd * @param eInd */ protected void verifyContentGeneralAcceptance( Event ev, Vector<Element> alphabet, BitSet bs, long[] sup, Vector<Integer>[] seqDB, Vector<Integer>[] posDB, int sInd, int eInd) { ItemSet set = ev.getSet(); for (int i = 0; i < set.size(); i++) { Element el = set.elementAt(i); int found = alphabet.indexOf(el); if (-1 != found) { // If current sequence did not contribute to the support of // this element yet, increment its support if (!bs.get(found)) { sup[found]++; bs.set(found); } // In any case, add another object to projecyed db seqDB[found].addElement(new Integer(sInd)); posDB[found].addElement(new Integer(eInd)); } } }
public int doNestedConjunctions(int iter, int maxOuterClauses, int maxClauses) throws IOException { int ret = 0; long nMatches = 0; for (int i = 0; i < iter; i++) { int oClauses = r.nextInt(maxOuterClauses - 1) + 2; BooleanQuery oq = new BooleanQuery(); BitSet result = null; for (int o = 0; o < oClauses; o++) { int nClauses = r.nextInt(maxClauses - 1) + 2; // min 2 clauses BooleanQuery bq = new BooleanQuery(); for (int j = 0; j < nClauses; j++) { result = addClause(bq, result); } oq.add(bq, BooleanClause.Occur.MUST); } // outer CountingHitCollector hc = validate ? new MatchingHitCollector(result) : new CountingHitCollector(); s.search(oq, hc); nMatches += hc.getCount(); ret += hc.getSum(); if (validate) assertEquals(result.cardinality(), hc.getCount()); // System.out.println(hc.getCount()); } System.out.println("Average number of matches=" + (nMatches / iter)); return ret; }