/** * Ensure there are at least <code>maxBucketOrd</code> buckets available. */ public final void grow(long maxBucketOrd) { docCounts = bigArrays.grow(docCounts, maxBucketOrd); }
private void ensureCapacity(long numBuckets) { runLens = bigArrays.grow(runLens, numBuckets << p); }
void ensureCapacity(long offset) { if (offset > Integer.MAX_VALUE) { throw new IllegalArgumentException(getClass().getSimpleName() + " cannot hold more than 2GB of data"); } bytes = bigArrays.grow(bytes, offset); }
/** * Utility method to increment the doc counts of the given bucket (identified by the bucket ordinal) */ public final void incrementBucketDocCount(long bucketOrd, int inc) { docCounts = bigArrays.grow(docCounts, bucketOrd + 1); docCounts.increment(bucketOrd, inc); }
@Override void copyCurrent(int slot) { values = bigArrays.grow(values, slot+1); values.set(slot, currentValue); }
private void append(long id, long key) { keys = bigArrays.grow(keys, id + 1); keys.set(id, key); }
private void append(long id, BytesRef key, int code) { assert size == id; final long startOffset = startOffsets.get(size); bytes = bigArrays.grow(bytes, startOffset + key.length); bytes.set(startOffset, key.bytes, key.offset, key.length); startOffsets = bigArrays.grow(startOffsets, size + 2); startOffsets.set(size + 1, startOffset + key.length); hashes = bigArrays.grow(hashes, id + 1); hashes.set(id, code); }
/** * Copies the current value in <code>slot</code>. */ private void copyCurrent(int slot) { for (int i = 0; i < arrays.length; i++) { arrays[i].copyCurrent(slot); } docCounts = bigArrays.grow(docCounts, slot+1); docCounts.set(slot, 1); }
public void collect(int docId, long parentBucket) throws IOException { perBucketSamples = bigArrays.grow(perBucketSamples, parentBucket + 1); PerParentBucketSamples sampler = perBucketSamples.get((int) parentBucket); if (sampler == null) { sampler = new PerParentBucketSamples(parentBucket, currentScorer, readerContext); perBucketSamples.set((int) parentBucket, sampler); } sampler.collect(docId); maxDocId = Math.max(maxDocId, docId); } }
private void fill(int index, boolean bit) { int wordNum = index >> 6; bits = bigArrays.grow(bits,wordNum+1); long bitmask = 1L << index; long value = bit ? bits.get(wordNum) | bitmask : bits.get(wordNum) & ~bitmask; bits.set(wordNum, value); }
@Override public void collect(int doc, long bucket) throws IOException { counts = bigArrays.grow(counts, bucket + 1); if (values.advanceExact(doc)) { counts.increment(bucket, values.docValueCount()); } }
@Override void copyCurrent(int slot) { values = bigArrays.grow(values, slot+1); if (missingBucket && missingCurrentValue) { bits.clear(slot); } else { assert missingCurrentValue == false; if (missingBucket) { bits.set(slot); } values.set(slot, currentValue); } }
@Override void copyCurrent(int slot) { values = bigArrays.grow(values, slot+1); if (missingBucket && missingCurrentValue) { bits.clear(slot); } else { assert missingCurrentValue == false; if (missingBucket) { bits.set(slot); } values.set(slot, currentValue); } }
/** * Add <code>k</code> to the hash table associated with <code>bucket</code>. * Return {@code -1} if the value was already in the set or the new set size if it was added. */ public int add(long bucket, int k) { sizes = bigArrays.grow(sizes, bucket + 1); assert k != 0; for (int i = (k & mask); ; i = (i + 1) & mask) { final int v = get(bucket, i); if (v == 0) { // means unused, take it! set(bucket, i, k); return sizes.increment(bucket, 1); } else if (v == k) { // k is already in the set return -1; } } }
@Override public void collect(int doc, long bucket) throws IOException { if (bucket >= mins.size()) { long from = mins.size(); mins = bigArrays.grow(mins, bucket + 1); mins.fill(from, mins.size(), Double.POSITIVE_INFINITY); } if (values.advanceExact(doc)) { final double value = values.doubleValue(); double min = mins.get(bucket); min = Math.min(min, value); mins.set(bucket, min); } }
@Override public void collect(int doc, long bucket) throws IOException { if (bucket >= maxes.size()) { long from = maxes.size(); maxes = bigArrays.grow(maxes, bucket + 1); maxes.fill(from, maxes.size(), Double.NEGATIVE_INFINITY); } if (values.advanceExact(doc)) { final double value = values.doubleValue(); double max = maxes.get(bucket); max = Math.max(max, value); maxes.set(bucket, max); } }
@Override void copyCurrent(int slot) { values = bigArrays.grow(values, slot+1); valueBuilders = bigArrays.grow(valueBuilders, slot+1); BytesRefBuilder builder = valueBuilders.get(slot); int byteSize = builder == null ? 0 : builder.bytes().length; if (builder == null) { builder = new BytesRefBuilder(); valueBuilders.set(slot, builder); } if (missingBucket && currentValue == null) { values.set(slot, null); } else { assert currentValue != null; builder.copyBytes(currentValue); breakerConsumer.accept(builder.bytes().length - byteSize); values.set(slot, builder.get()); } }
@Override public void collect(int doc, long bucketOrd) throws IOException { visitedOrds = bigArrays.grow(visitedOrds, bucketOrd + 1); FixedBitSet bits = visitedOrds.get(bucketOrd); if (bits == null) { bits = new FixedBitSet(maxOrd); visitedOrds.set(bucketOrd, bits); } if (values.advanceExact(doc)) { for (long ord = values.nextOrd(); ord != SortedSetDocValues.NO_MORE_ORDS; ord = values.nextOrd()) { bits.set((int) ord); } } }
@Override public void collect(int doc, long bucket) throws IOException { states = bigArrays.grow(states, bucket + 1); TDigestState state = states.get(bucket); if (state == null) { state = new TDigestState(compression); states.set(bucket, state); } if (values.advanceExact(doc)) { final int valueCount = values.docValueCount(); for (int i = 0; i < valueCount; i++) { state.add(values.nextValue()); } } } };
@Override public void collect(int doc, long bucket) throws IOException { valueSketches = bigArrays.grow(valueSketches, bucket + 1); TDigestState valueSketch = valueSketches.get(bucket); if (valueSketch == null) { valueSketch = new TDigestState(compression); valueSketches.set(bucket, valueSketch); } if (values.advanceExact(doc)) { final int valueCount = values.docValueCount(); for (int i = 0; i < valueCount; i++) { final double value = values.nextValue(); valueSketch.add(value); } } } };