@Override public void collect(int doc) throws IOException { if (values != null) { int ord = (int) ordinals.getOrd(doc); long parentIdx = parentIdsIndex.get(ord); if (parentIdx < 0) { final BytesRef bytes = values.getValueByOrd(ord); final int hash = values.currentValueHash(); parentIdx = parentIds.add(bytes, hash); if (parentIdx < 0) { parentIdx = -parentIdx - 1; scores.increment(parentIdx, scorer.score()); occurrences.increment(parentIdx, 1); } else { scores = bigArrays.grow(scores, parentIdx + 1); scores.set(parentIdx, scorer.score()); occurrences = bigArrays.grow(occurrences, parentIdx + 1); occurrences.set(parentIdx, 1); } parentIdsIndex.set(ord, parentIdx); } else { scores.increment(parentIdx, scorer.score()); occurrences.increment(parentIdx, 1); } } }
public static void main(String[] args) { final int size = 10_000; IntArray ia = new IntArray(size); IntArrayVolatile iav = new IntArrayVolatile(size); Mark7("IntArray", i -> ia.isSorted() ? 1.0 : 0.0); Mark7("IntArrayVolatile", i -> iav.isSorted() ? 1.0 : 0.0); Mark7("IntArray", i -> ia.isSorted() ? 1.0 : 0.0); Mark7("IntArrayVolatile", i -> iav.isSorted() ? 1.0 : 0.0); }
@NotNull public synchronized int[] get(final int id) { assertPointer(id); try { if (id >= pointers.size) { return ArrayUtil.EMPTY_INT_ARRAY; } int arrayBase = pointers.get(id); IntArray array = arrayBase == 0 ? EMPTY : new IntArray(data, arrayBase); return array.toArray(); } catch (IOException e) { throw new RuntimeException(e); } }
public void testIntArrayGrowth() { final int totalLen = randomIntBetween(1, 1000000); final int startLen = randomIntBetween(1, randomBoolean() ? 1000 : totalLen); IntArray array = bigArrays.newIntArray(startLen, randomBoolean()); int[] ref = new int[totalLen]; for (int i = 0; i < totalLen; ++i) { ref[i] = randomInt(); array = bigArrays.grow(array, i + 1); array.set(i, ref[i]); } for (int i = 0; i < totalLen; ++i) { assertEquals(ref[i], array.get(i)); } array.close(); }
private IntArray reallocWith(ByteBuffer bytes, int maxSize) throws IOException { assert maxSize > 0 && maxSize < MAX_LIST_LENGTH : maxSize; int newSize = Math.max(maxSize, bytes.limit() / 4); int newCapacity = newSize < 10 ? (newSize + 1) * 2 : newSize * 3 / 2; int newBase = (int) data.size(); writeInt(data, newBase, newSize); writeInt(data, newBase + 4, newCapacity); bytes.position(0); data.write(bytes, newBase + 8); fillWithZeros(data, newBase + 8 + newSize * 4, (newCapacity - newSize) * 4); IntArray array = new IntArray(data, newBase); assert array.size == newSize; assert array.capacity == newCapacity; assert array.base == newBase; array.assertListLength(); return array; }
protected int binarySearchForNearest(int val, int begin, int end) { int mid = (begin + end) / 2; int midval = array.get(mid); if (mid == end) return midval >= val ? mid : -1; if (midval < val) { // Find number equal or greater than the target. if (array.get(mid + 1) >= val) return mid + 1; return binarySearchForNearest(val, mid + 1, end); } else { // Find number equal or greater than the target. if (midval == val) return mid; return binarySearchForNearest(val, begin, mid); } }
public synchronized void addAll(final int id, @NotNull final int[] values) { assert 0 < values.length && values.length <= MAX_LIST_LENGTH : values.length; assert id > 0; Arrays.sort(values); try { if (id >= pointers.size) { pointers = pointers.reallocWith(pointers.toBuffer(), id + 1); writeInt(data, 0, pointers.base); assert pointers.size > id : id + " > " + pointers.size; } int arrayBase = pointers.get(id); IntArray array = arrayBase == 0 ? EMPTY : new IntArray(data, arrayBase); IntArray newArray = array.addAll(values); if (newArray != null) { pointers.put(id, newArray.base); } } catch (IOException e) { throw new RuntimeException(e); } int[] ids = get(id); assertSorted(ids); TIntHashSet set = new TIntHashSet(ids); assert set.containsAll(values) : "ids: " + Arrays.toString(ids) + ";\n values:" + Arrays.toString(values); }
public static @infix void toString(Object o, StringBuilder builder) { if (o == null) { builder.append("null"); return; } Class c = o.getClass(); if (c == String.class) { builder.append((String) o); return; } if (c == boolean[].class) { BooleanArray.toString((boolean[]) o, builder); return; } if (c == byte[].class) { ByteArray.toString((byte[]) o, builder); return; } if (c == short[].class) { ShortArray.toString((short[]) o, builder); return; } if (c == char[].class) { CharArray.toString((char[]) o, builder); return; } if (c == int[].class) { IntArray.toString((int[]) o, builder); return; } if (c == long[].class) { LongArray.toString((long[]) o, builder); return; } if (c == float[].class) { FloatArray.toString((float[]) o, builder); return; } if (c == double[].class) { DoubleArray.toString((double[]) o, builder); return; } if (c.isArray()) { deepToString((Object[]) o, builder); return; } builder.append(o.toString()); }
@Override public int advance(int target) throws IOException { if (remaining == 0) { return currentDocId = NO_MORE_DOCS; } currentDocId = parentsIterator.advance(target); if (currentDocId == DocIdSetIterator.NO_MORE_DOCS) { return currentDocId; } bytesValues.setDocument(currentDocId); long index = parentIds.find(bytesValues.nextValue(), bytesValues.currentValueHash()); if (index != -1) { currentScore = scores.get(index); currentScore /= occurrences.get(index); remaining--; return currentDocId; } else { return nextDoc(); } }
public VzOFF(String path, VzMesh.Style style) throws IOException { this.path = path; this.style = style; BufferedReader ins = new BufferedReader(new FileReader(new File(path))); FloatArray vertexArray = new FloatArray(); IntArray indexArray = new IntArray(); FloatArray normalArray; String header = ins.readLine(); if (!header.equals("OFF")) throw new IOException("Not an OFF file"); int nvertexArray, nfaces, nedges; if (true) { String sizes = ins.readLine(); String toks[] = fastSplit(sizes); nvertexArray = Integer.parseInt(toks[0]); nfaces = Integer.parseInt(toks[1]); nedges = Integer.parseInt(toks[2]); } for (int i = 0; i < nvertexArray; i++) { String line = ins.readLine(); String toks[] = fastSplit(line); float x = Float.parseFloat(toks[0]); float y = Float.parseFloat(toks[1]); float z = Float.parseFloat(toks[2]); xyz_min[0] = Math.min(xyz_min[0], x); xyz_min[1] = Math.min(xyz_min[1], y); xyz_min[2] = Math.min(xyz_min[2], z); xyz_max[0] = Math.max(xyz_max[0], x); xyz_max[1] = Math.max(xyz_max[1], y); xyz_max[2] = Math.max(xyz_max[2], z); vertexArray.add(x); vertexArray.add(y); vertexArray.add(z); } float vs[] = vertexArray.getData(); float ns[] = new float[vs.length]; normalArray = new FloatArray(ns); for (int i = 0; i < nfaces; i++) { String line = ins.readLine(); String toks[] = fastSplit(line); int len = Integer.parseInt(toks[0]); assert (len + 1 == toks.length); for (int j = 2; j + 1 <= len; j++) { int a = Integer.parseInt(toks[1]); int b = Integer.parseInt(toks[j]); int c = Integer.parseInt(toks[j + 1]); indexArray.add(a); indexArray.add(b); indexArray.add(c); float vba[] = new float[] { vs[b * 3 + 0] - vs[a * 3 + 0], vs[b * 3 + 1] - vs[a * 3 + 1], vs[b * 3 + 2] - vs[a * 3 + 2] }; float vca[] = new float[] { vs[c * 3 + 0] - vs[a * 3 + 0], vs[c * 3 + 1] - vs[a * 3 + 1], vs[c * 3 + 2] - vs[a * 3 + 2] }; float n[] = LinAlg.normalize(LinAlg.crossProduct(vba, vca)); for (int k = 0; k < 3; k++) { ns[3 * a + k] += n[k]; ns[3 * b + k] += n[k]; ns[3 * c + k] += n[k]; } } } for (int i = 0; i + 2 < ns.length; i += 3) { double mag = Math.sqrt(ns[i + 0] * ns[i + 0] + ns[i + 1] * ns[i + 1] + ns[i + 2] * ns[i + 2]); ns[i + 0] /= mag; ns[i + 1] /= mag; ns[i + 2] /= mag; } mesh = new VzMesh( new VisVertexData(vs, vs.length / 3, 3), new VisVertexData(ns, ns.length / 3, 3), new VisIndexData(indexArray), VzMesh.TRIANGLES); ins.close(); }
/** Returns a new array containing the remaining values. */ public IntArray toArray() { IntArray array = new IntArray(true, map.size); while (hasNext) array.add(next()); return array; }
@Override public void addDoc(int docid) { ++pos; array.add(docid); }
@Override public long sizeInBytes() { // Object Overhead return array.length() * 4 + 64; }