/** * Get min clock of this row, remove clocks of tasks which would never update this row. * * @return min clock value */ public int getMinClock() { if (clocks.size() == 0) { return 0; } IntIterator iter = clocks.values().iterator(); int min = Integer.MAX_VALUE; while (iter.hasNext()) { int clock = iter.nextInt(); if (clock < min) { min = clock; } } return min; }
public String listRowIds() { int[] idList = new int[rowIdSet.size()]; IntIterator iter = rowIdSet.iterator(); int i = 0; while (iter.hasNext()) { idList[i++] = iter.nextInt(); } Arrays.sort(idList); StringBuilder sb = new StringBuilder(); for (i = 0; i < idList.length; i++) { sb.append(idList[i]); sb.append(","); } return sb.toString(); }
private DebugLocalsChange createLocalsChange( Int2ReferenceMap<DebugLocalInfo> ending, Int2ReferenceMap<DebugLocalInfo> starting) { if (ending.isEmpty() && starting.isEmpty()) { return null; } if (ending.isEmpty() || starting.isEmpty()) { return new DebugLocalsChange(ending, starting); } IntSet unneeded = new IntArraySet(Math.min(ending.size(), starting.size())); for (Entry<DebugLocalInfo> entry : ending.int2ReferenceEntrySet()) { if (starting.get(entry.getIntKey()) == entry.getValue()) { unneeded.add(entry.getIntKey()); } } if (unneeded.size() == ending.size() && unneeded.size() == starting.size()) { return null; } IntIterator iterator = unneeded.iterator(); while (iterator.hasNext()) { int key = iterator.nextInt(); ending.remove(key); starting.remove(key); } return new DebugLocalsChange(ending, starting); }
public boolean intersectionPE(CustomHashMap other){ boolean modified = false; IntIterator itr = this.keySet().iterator(); while(itr.hasNext()){ int key = itr.nextInt(); int keyInv = 0 - key; if(!other.containsKey(key) && !other.containsKey(keyInv)){ itr.remove(); modified = true; } } for(int otherKey : other.keySet()){ int otherKeyInv = 0-otherKey; boolean intst = this.containsKey(otherKey); //does this contain otherKey? boolean intstPrime = this.containsKey(otherKeyInv); //does this contain -(otherkey)? if(!intst && intstPrime){ this.put(otherKey, other.get(otherKey)); modified = true; } } return modified; }
public Attribute createNewAttribute(HashMap<String, Attribute> attributes, String attribute, int noMonths) { Attribute a = attributes.get(attribute); int ct = 0; IntSet keys = a.data.keySet(); IntIterator it = keys.iterator(); ArrayList<SpatioTemporalVal> arr = new ArrayList<SpatioTemporalVal>(); while(ct < noMonths) { if(!it.hasNext()) { Utilities.er("no. of months is greater than what is present"); } int month = it.nextInt(); arr.addAll(a.data.get(month)); ct++; } Collections.sort(arr); Attribute na = new Attribute(); na.data.put(0, arr); na.nodeSet = a.nodeSet; return na; }
/** * Returns an iterator over elements of type {@code T}. * * @return an Iterator. */ @Override public Iterator<LocalTime> iterator() { return new Iterator<LocalTime>() { IntIterator intIterator = intIterator(); @Override public boolean hasNext() { return intIterator.hasNext(); } @Override public LocalTime next() { return PackedLocalTime.asLocalTime(intIterator.nextInt()); } }; }
/** * Returns an iterator over elements of type {@code T}. * * @return an Iterator. */ @Override public Iterator<LocalDate> iterator() { return new Iterator<LocalDate>() { IntIterator intIterator = intIterator(); @Override public boolean hasNext() { return intIterator.hasNext(); } @Override public LocalDate next() { return PackedLocalDate.asLocalDate(intIterator.nextInt()); } }; }
@Test public void testInternalIdToLongIterator() { LongToInternalIntBiMap nodesToIndexBiMap = new ArrayBasedLongToInternalIntBiMap(10, 0.5, -1, -1L, nullStatsReceiver); int n = 7; int[] expectedIndices = new int[n]; long[] expectedEntries = new long[n]; for (int i = 0; i < n; i++) { expectedIndices[i] = nodesToIndexBiMap.put(i); expectedEntries[i] = (long) i; } IntIterator intIterator = new IntArrayList(expectedIndices).iterator(); InternalIdToLongIterator internalIdToLongIterator = new InternalIdToLongIterator(nodesToIndexBiMap, new IdentityEdgeTypeMask()); internalIdToLongIterator.resetWithIntIterator(new WithEdgeMetadataIntIteratorImpl(intIterator)); assertEquals(new LongArrayList(expectedEntries), new LongArrayList(internalIdToLongIterator)); }
private Int2IntMap getFasterIntersectionMap(int uidx) { Int2IntOpenHashMap intersectionMap = new Int2IntOpenHashMap(); intersectionMap.defaultReturnValue(0); IntIterator iidxs = data.getUidxIidxs(uidx); while (iidxs.hasNext()) { IntIterator vidxs = data.getIidxUidxs(iidxs.nextInt()); while (vidxs.hasNext()) { intersectionMap.addTo(vidxs.nextInt(), 1); } } intersectionMap.remove(uidx); return intersectionMap; }
private Int2DoubleMap getProductMap(int uidx) { Int2DoubleOpenHashMap productMap = new Int2DoubleOpenHashMap(); productMap.defaultReturnValue(0.0); if (data.useIteratorsPreferentially()) { IntIterator iidxs = data.getUidxIidxs(uidx); DoubleIterator ivs = data.getUidxVs(uidx); while (iidxs.hasNext()) { int iidx = iidxs.nextInt(); double iv = ivs.nextDouble(); IntIterator vidxs = data.getIidxUidxs(iidx); DoubleIterator vvs = data.getIidxVs(iidx); while (vidxs.hasNext()) { productMap.addTo(vidxs.nextInt(), iv * vvs.nextDouble()); } } } else { data.getUidxPreferences(uidx) .forEach(ip -> data.getIidxPreferences(ip.v1) .forEach(up -> productMap.addTo(up.v1, ip.v2 * up.v2))); } productMap.remove(uidx); return productMap; }
private double[] getProductArray(int uidx) { double[] productArray = new double[data.numUsers()]; if (data.useIteratorsPreferentially()) { IntIterator iidxs = data.getUidxIidxs(uidx); DoubleIterator ivs = data.getUidxVs(uidx); while (iidxs.hasNext()) { int iidx = iidxs.nextInt(); double iv = ivs.nextDouble(); IntIterator vidxs = data.getIidxUidxs(iidx); DoubleIterator vvs = data.getIidxVs(iidx); while (vidxs.hasNext()) { productArray[vidxs.nextInt()] += iv * vvs.nextDouble(); } } } else { data.getUidxPreferences(uidx) .forEach(ip -> data.getIidxPreferences(ip.v1) .forEach(up -> productArray[up.v1] += ip.v2 * up.v2)); } productArray[uidx] = 0.0; return productArray; }
/** * Estimates the number of bits required for the succinct delta representation from strictly incremental * <code>list</code>. For details of the representation (see * {@link org.pebble.core.encoding.OutputSuccinctStream#writeDelta(it.unimi.dsi.fastutil.ints.IntList, int) writeDelta}). * @param list to encode. List must be strictly incremental with positives (including zero) values. * @param valueBitSize fixed number of bits used to represent value in list to be encoded. It can be any value * between 1bit and 31 bits. * @return number of representation bits. */ public int getWriteDeltaOffset(final IntList list, final int valueBitSize) { final IntIterator listIterator = list.iterator(); int offset = getWriteDeltaOffset(list.size()); if (listIterator.hasNext()) { int value; int deltaValue; int lastValue = listIterator.nextInt(); offset += writeIntOffset(lastValue, valueBitSize); while (listIterator.hasNext()) { value = listIterator.nextInt(); deltaValue = value - lastValue - 1; offset += getWriteDeltaOffset(deltaValue); lastValue = value; } } return offset; }
@Nullable public static <T> T getWeightedRandomReversed(Random random, Int2ObjectMap<T> choices) { long i = 0; IntSet ints = choices.keySet(); for (IntIterator iterator = ints.iterator(); iterator.hasNext(); ) { int x = iterator.nextInt(); i += x; } i = getRandomLong(random, 0, i); for (Int2ObjectMap.Entry<T> entry : choices.int2ObjectEntrySet()) { i -= entry.getIntKey(); if (i < 0) { return entry.getValue(); } } return null; }
@Nullable public static <T> T getWeightedRandom(Random random, Object2IntMap<T> choices) { long i = 0; IntCollection ints = choices.values(); for (IntIterator iterator = ints.iterator(); iterator.hasNext(); ) { int x = iterator.nextInt(); i += x; } i = getRandomLong(random, 0, i); for (Object2IntMap.Entry<T> entry : choices.object2IntEntrySet()) { i -= entry.getIntValue(); if (i < 0) { return entry.getKey(); } } return null; }
private int acquire0() { final int id; final IntIterator it = allocatorReusableIds.iterator(); if (it.hasNext()) { try { id = it.nextInt(); } finally { it.remove(); } } else { id = allocatorIdCounter++; } if (this.entityProtocol != null) { this.entityProtocol.entityProtocolManager.idToEntityProtocolMap.put(id, this.entityProtocol); } return id; }
public IntCollection values() { if ( values == null ) values = new AbstractIntCollection () { public IntIterator iterator() { return new ValueIterator(); } public int size() { return size; } public boolean contains( int v ) { return containsValue( v ); } public void clear() { Int2IntOpenHashMap.this.clear(); } }; return values; }
public void testMerge( int n0, int n1 ) { Random r = new Random(); int x0[] = new int[ n0 ]; int x1[] = new int[ n1 ]; int i, p = 0; // Generate for ( i = 0; i < n0; i++ ) p = x0[ i ] = p + r.nextInt( 10 ); p = 0; for ( i = 0; i < n1; i++ ) p = x1[ i ] = p + (int)( Math.random() * 10 ); IntAVLTreeSet s0 = new IntAVLTreeSet( x0 ); IntAVLTreeSet s1 = new IntAVLTreeSet( x1 ); IntAVLTreeSet res = new IntAVLTreeSet( s0 ); res.addAll( s1 ); MergedIntIterator m = new MergedIntIterator( LazyIntIterators.lazy( s0.iterator() ), LazyIntIterators.lazy( s1.iterator() ) ); IntIterator it = res.iterator(); int x; while ( ( x = m.nextInt() ) != -1 ) assertEquals( it.nextInt(), x ); assertEquals( Boolean.valueOf( it.hasNext() ), Boolean.valueOf( m.nextInt() != -1 ) ); }
public String createGraphWithFixedWidthLabels( File basename, ImmutableGraph g, int width ) throws IllegalArgumentException, SecurityException, IOException { final int n = g.numNodes(); System.err.println( "Testing " + n + " nodes, width " + width+ ", basename " + basename ); OutputBitStream labels = createTempBitStream( basename + "-fixedlabel" + BitStreamArcLabelledImmutableGraph.LABELS_EXTENSION ); OutputBitStream offsets = createTempBitStream( basename + "-fixedlabel" + BitStreamArcLabelledImmutableGraph.LABEL_OFFSETS_EXTENSION ); offsets.writeGamma( 0 ); for( int i = 0; i < n; i++ ) { int bits = 0; for( IntIterator j = LazyIntIterators.eager( g.successors( i ) ); j.hasNext(); ) bits += labels.writeInt( i * j.nextInt() + i, width ); offsets.writeGamma( bits ); } labels.close(); offsets.close(); PrintWriter pw = new PrintWriter( new FileWriter( basename + "-fixedlabel.properties" ) ); pw.println( ImmutableGraph.GRAPHCLASS_PROPERTY_KEY + " = " + BitStreamArcLabelledImmutableGraph.class.getName() ); pw.println( BitStreamArcLabelledImmutableGraph.LABELSPEC_PROPERTY_KEY + " = " + FixedWidthIntLabel.class.getName() + "(TEST," + width + ")" ); pw.println( ArcLabelledImmutableGraph.UNDERLYINGGRAPH_PROPERTY_KEY + " = " + basename.getName() ); pw.close(); return basename + "-fixedlabel"; }
public String createGraphWithGammaLabels( File basename, ImmutableGraph g ) throws IllegalArgumentException, SecurityException, IOException { // We create a complete graph with labels final int n = g.numNodes(); System.err.println( "Testing " + n + " nodes, gamma coding, basename " + basename ); OutputBitStream labels = createTempBitStream( basename + "-gammalabel" + BitStreamArcLabelledImmutableGraph.LABELS_EXTENSION ); OutputBitStream offsets = createTempBitStream( basename + "-gammalabel" + BitStreamArcLabelledImmutableGraph.LABEL_OFFSETS_EXTENSION ); offsets.writeGamma( 0 ); for( int i = 0; i < n; i++ ) { int bits = 0; for( IntIterator j = LazyIntIterators.eager( g.successors( i ) ); j.hasNext(); ) bits += labels.writeGamma( i * j.nextInt() + i ); offsets.writeGamma( bits ); } labels.close(); offsets.close(); PrintWriter pw = new PrintWriter( new FileWriter( basename + "-gammalabel" + ImmutableGraph.PROPERTIES_EXTENSION ) ); pw.println( ImmutableGraph.GRAPHCLASS_PROPERTY_KEY + " = " + BitStreamArcLabelledImmutableGraph.class.getName() ); pw.println( BitStreamArcLabelledImmutableGraph.LABELSPEC_PROPERTY_KEY + " = " + GammaCodedIntLabel.class.getName() + "(TEST)" ); pw.println( ArcLabelledImmutableGraph.UNDERLYINGGRAPH_PROPERTY_KEY + " = " + basename.getName() ); pw.close(); return basename + "-gammalabel"; }
@Test public void testConstructor() throws IllegalArgumentException, SecurityException { for( int n = 1; n < 8; n++ ) { for( int type = 0; type < 3; type++ ) { System.err.println( "Testing type " + type + ", n=" + n + "..." ); ArrayListMutableGraph g = type == 0 ? ArrayListMutableGraph.newCompleteGraph( n, false ) : type == 1 ? ArrayListMutableGraph.newCompleteBinaryIntree( n ) : ArrayListMutableGraph.newCompleteBinaryOuttree( n ); final ImmutableGraph immutableView = g.immutableView(); assertGraph( immutableView ); assertEquals( g, new ArrayListMutableGraph( immutableView ) ); int[][] arc = new int[ (int)g.numArcs() ][ 2 ]; for( int i = 0, k = 0; i < g.numNodes(); i++ ) for( IntIterator successors = g.successors( i ); successors.hasNext(); ) arc[ k++ ] = new int[] { i, successors.nextInt() }; assertEquals( g, new ArrayListMutableGraph( g.numNodes(), arc ) ); } } }
private int findSlotForPlayer(UUID playerUUID) { int targetSlot = -1; for (IntIterator iterator = skinUuidToSlotMap.get(playerUUID).iterator(); iterator.hasNext(); ) { int i = iterator.nextInt(); if (clientUuid[i] == fakePlayerUUIDs[i]) { targetSlot = i; break; } } if (targetSlot == -1) { for (int i = size - 1; i >= 0; i--) { if (clientUuid[i] == fakePlayerUUIDs[i]) { targetSlot = i; break; } } } if (targetSlot == -1) { throw new IllegalStateException("Not enough slots in tab list."); } return targetSlot; }
/** * Helper method to serialize an {@link IntOpenHashSet}. */ private static byte[] serializeIntOpenHashSet(IntOpenHashSet intOpenHashSet) throws IOException { ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream); // Write the size of the set. dataOutputStream.writeInt(intOpenHashSet.size()); IntIterator intIterator = intOpenHashSet.iterator(); while (intIterator.hasNext()) { dataOutputStream.writeInt(intIterator.nextInt()); } return byteArrayOutputStream.toByteArray(); }
@Override public Iterator<Edge<IntWritable, NullWritable>> iterator() { // Returns an iterator that reuses objects. return new UnmodifiableIterator<Edge<IntWritable, NullWritable>>() { /** Wrapped neighbors iterator. */ private IntIterator neighborsIt = neighbors.iterator(); /** Representative edge object. */ private Edge<IntWritable, NullWritable> representativeEdge = EdgeFactory.create(new IntWritable(), NullWritable.get()); @Override public boolean hasNext() { return neighborsIt.hasNext(); } @Override public Edge<IntWritable, NullWritable> next() { representativeEdge.getTargetVertexId().set(neighborsIt.nextInt()); return representativeEdge; } }; }
private RowIndex findNewRows(RowIndex rowIndex) { IntOpenHashSet need = new IntOpenHashSet(); IntOpenHashSet fetchingRowIds = fetchingRowSets.get(rowIndex.getMatrixId()); IntIterator iter = rowIndex.getRowIds().iterator(); while (iter.hasNext()) { int rowId = iter.nextInt(); if (!fetchingRowIds.contains(rowId)) { need.add(rowId); fetchingRowIds.add(rowId); } } return new RowIndex(rowIndex.getMatrixId(), need, rowIndex); }
void intersectReferenced(final IntSet attributes, final Attribute[] attributeIndex) { final IntIterator referencedIterator = referenced.iterator(); while (referencedIterator.hasNext()) { final int ref = referencedIterator.nextInt(); if (attributes.contains(ref)) { continue; } referencedIterator.remove(); attributeIndex[ref].removeDependent(id); } }
public void printReads(){ IntIterator itr = this.keySet().iterator(); HLA.log.append("{"); while(itr.hasNext()) HLA.log.append(" (" +itr.nextInt() + ") "); HLA.log.appendln("}"); }
public boolean intersection(CustomHashMap other){ boolean modified = false; IntIterator itr = this.keySet().iterator(); while(itr.hasNext()){ int curInt = itr.nextInt(); if(!other.containsKey(curInt)){ itr.remove(); modified = false; } } return modified; }
public boolean removeAll(CustomHashMap other){ boolean modified = false; IntIterator itr = other.keySet().iterator(); int curKey; while(itr.hasNext()){ curKey = itr.next(); if(this.containsKey(curKey)){ this.remove(curKey); modified = true; } } return modified; }
public void printKeys(){ IntIterator itr = this.keySet().iterator(); HLA.log.append("{"); if(this.size() > 0) HLA.log.append(itr.nextInt()); while(itr.hasNext()) HLA.log.append("," + itr.nextInt()); HLA.log.appendln("}"); }
/** {@inheritDoc} */ @Override public int nonZeroElements() { int res = 0; IntIterator rowIter = indexesMap().keySet().iterator(); while (rowIter.hasNext()) { int row = rowIter.nextInt(); res += indexesMap().get(row).size(); } return res; }
@Nonnull public int[] getUsers() { final int size = rows.size(); final int[] keys = new int[size]; final IntIterator itor = rows.keySet().iterator(); for (int i = 0; i < size; i++) { if (!itor.hasNext()) { throw new IllegalStateException(); } int key = itor.nextInt(); keys[i] = key; } return keys; }
public TimeColumn selectIf(LocalTimePredicate predicate) { TimeColumn column = emptyCopy(); IntIterator iterator = intIterator(); while (iterator.hasNext()) { int next = iterator.nextInt(); if (predicate.test(PackedLocalTime.asLocalTime(next))) { column.appendInternal(next); } } return column; }
/** * This version operates on predicates that treat the given IntPredicate as operating on a packed local time * This is much more efficient that using a LocalTimePredicate, but requires that the developer understand the * semantics of packedLocalTimes */ public TimeColumn selectIf(IntPredicate predicate) { TimeColumn column = emptyCopy(); IntIterator iterator = intIterator(); while (iterator.hasNext()) { int next = iterator.nextInt(); if (predicate.test(next)) { column.appendInternal(next); } } return column; }
/** * Returns a bitmap flagging the records for which the value in this column is equal to the value in the given * column * Columnwise isEqualTo. */ public Selection isEqualTo(TimeColumn column) { Selection results = new BitmapBackedSelection(); int i = 0; IntIterator intIterator = column.intIterator(); for (int next : data) { if (next == intIterator.nextInt()) { results.add(i); } i++; } return results; }
/** * Returns a bitmap flagging the records for which the value in this column is equal to the value in the given * column * Columnwise isEqualTo. */ public Selection isEqualTo(DateColumn column) { Selection results = new BitmapBackedSelection(); int i = 0; IntIterator intIterator = column.intIterator(); for (int next : data) { if (next == intIterator.nextInt()) { results.add(i); } i++; } return results; }