@Override public int prevSetBit(int i) { assert i >= 0; final int i4096 = i >>> 12; final long index = indices[i4096]; final long[] bitArray = this.bits[i4096]; int i64 = i >>> 6; final long indexBits = index & ((1L << i64) - 1); final int o = Long.bitCount(indexBits); if ((index & (1L << i64)) != 0) { // There is at least one bit that is set in the same long, check if there // is one bit that is set that is lower than i final long bits = bitArray[o] & ((1L << i << 1) - 1); if (bits != 0) { return (i64 << 6) | (63 - Long.numberOfLeadingZeros(bits)); } } if (indexBits == 0) { // no more bits are set in this block, go find the last bit in the // previous block return lastDoc(i4096 - 1); } // go to the previous long i64 = 63 - Long.numberOfLeadingZeros(indexBits); final long bits = bitArray[o - 1]; return (i4096 << 12) | (i64 << 6) | (63 - Long.numberOfLeadingZeros(bits)); }
private void initHCI() { // LHC, NI, ... long maxHcAddr = ~((-1L) << dims); int nSetFilterBits = Long.bitCount(maskLower | ((~maskUpper) & maxHcAddr)); // nPossibleMatch = (2^k-x) long nPossibleMatch = 1L << (dims - nSetFilterBits); if (isNI) { int nChild = node.ntGetSize(); int logNChild = Long.SIZE - Long.numberOfLeadingZeros(nChild); // the following will overflow for k=60 boolean useHcIncrementer = (nChild > nPossibleMatch * (double) logNChild * 2); // DIM < 60 as safeguard against overflow of (nPossibleMatch*logNChild) if (useHcIncrementer && PhTree11.HCI_ENABLED && dims < 50) { useNiHcIncrementer = true; } else { useNiHcIncrementer = false; } } else if (PhTree11.HCI_ENABLED) { if (isHC) { // nPossibleMatch < 2^k? // PAPER useHcIncrementer = nPossibleMatch * 2 <= maxHcAddr; } else { int logNPost = Long.SIZE - Long.numberOfLeadingZeros(nMaxEntry) + 1 + 1; useHcIncrementer = (nMaxEntry >= 2 * nPossibleMatch * (double) logNPost); } } }
/** Return the last document that occurs on or before the provided block index. */ private int lastDoc(int i4096) { long index; while (i4096 >= 0) { index = indices[i4096]; if (index != 0) { final int i64 = 63 - Long.numberOfLeadingZeros(index); final long bits = this.bits[i4096][Long.bitCount(index) - 1]; return (i4096 << 12) | (i64 << 6) | (63 - Long.numberOfLeadingZeros(bits)); } i4096 -= 1; } return -1; }
/** * Find the index of the previous set bit less than or equal to i, returns -1 if none found. * * @param i starting index * @return index of the previous set bit */ public int prevSetBit(final int i) { int x = i >> 6; // i / 64 with sign extension long w = bitmap[x]; w <<= 64 - i - 1; if (w != 0) { return i - Long.numberOfLeadingZeros(w); } for (--x; x >= 0; --x) { if (bitmap[x] != 0) { return x * 64 + 63 - Long.numberOfLeadingZeros(bitmap[x]); } } return -1; }
public BytesBytesMultiHashMap(int initialCapacity, float loadFactor, int wbSize, long memUsage) { if (loadFactor < 0 || loadFactor > 1) { throw new AssertionError("Load factor must be between (0, 1]."); } assert initialCapacity > 0; initialCapacity = (Long.bitCount(initialCapacity) == 1) ? initialCapacity : nextHighestPowerOfTwo(initialCapacity); // 8 bytes per long in the refs, assume data will be empty. This is just a sanity check. int maxCapacity = (memUsage <= 0) ? DEFAULT_MAX_CAPACITY : (int) Math.min((long) DEFAULT_MAX_CAPACITY, memUsage / 8); if (maxCapacity < initialCapacity || initialCapacity <= 0) { // Either initialCapacity is too large, or nextHighestPowerOfTwo overflows initialCapacity = (Long.bitCount(maxCapacity) == 1) ? maxCapacity : nextLowestPowerOfTwo(maxCapacity); } validateCapacity(initialCapacity); startingHashBitCount = 63 - Long.numberOfLeadingZeros(initialCapacity); this.loadFactor = loadFactor; refs = new long[initialCapacity]; writeBuffers = new WriteBuffers(wbSize, MAX_WB_SIZE); resizeThreshold = (int) (initialCapacity * this.loadFactor); }
// Shifts long bits as double, if the digits is positive, left-shift; if // not, shift to right and calculate its carry. private static long shiftLongBits(long bits, long digits) { if (digits > 0) { return bits << digits; } // change it to positive long absdigits = -digits; if (!(Long.numberOfLeadingZeros(bits & ~DOUBLE_SIGN_MASK) <= (64 - absdigits))) { return 0; } long ret = bits >> absdigits; boolean halfbit = ((bits >> (absdigits - 1)) & 0x1) == 1; if (halfbit) { // some bits will remain after shifting, calculates its carry // subnormal if (Long.numberOfTrailingZeros(bits) < (absdigits - 1)) { ret = ret + 1; } if (Long.numberOfTrailingZeros(bits) == (absdigits - 1)) { if ((ret & 0x1) == 1) { ret = ret + 1; } } } return ret; }
/** Writes a signed integral to {@code out}. */ public static void writeSignedIntegralValue(ByteOutput out, int type, long value) { /* * Figure out how many bits are needed to represent the value, * including a sign bit: The bit count is subtracted from 65 * and not 64 to account for the sign bit. The xor operation * has the effect of leaving non-negative values alone and * unary complementing negative values (so that a leading zero * count always returns a useful number for our present * purpose). */ int requiredBits = 65 - Long.numberOfLeadingZeros(value ^ (value >> 63)); // Round up the requiredBits to a number of bytes. int requiredBytes = (requiredBits + 0x07) >> 3; /* * Write the header byte, which includes the type and * requiredBytes - 1. */ out.writeByte(type | ((requiredBytes - 1) << 5)); // Write the value, per se. while (requiredBytes > 0) { out.writeByte((byte) value); value >>= 8; requiredBytes--; } }
public static String formatSize(long value) { if (value < 1024) { return value + " B"; } int z = (63 - Long.numberOfLeadingZeros(value)) / 10; return String.format("%.1f %siB", (double) value / (1L << (z * 10)), " KMGTPE".charAt(z)); }
@Test(timeout = 5000L) public void powExactLongIntExact() { for (long base : LONGS) { for (int power : INTS) { if (power < 0) continue; boolean overflow = BigInteger.valueOf(63 - Long.numberOfLeadingZeros(Math.abs(base))) .multiply(BigInteger.valueOf(power)) .compareTo(BigInteger.valueOf(64)) > 0; BigInteger expected = overflow ? null : BigInteger.valueOf(base).pow(power); if (expected != null && expected.bitLength() <= 63) { long value = powExact(base, power); assertEquals(base + " ^ " + power, expected.longValue(), value); if (value < 10000000000000000L) assertEquals( base + " ^ " + power, power == 1 ? base : (long) Math.pow(base, power), value); assertEquals(base + " ^ " + power, pow(base, power), value); } else { try { powExact(base, power); fail("Should overflow: " + base + " ^ " + power); } catch (ArithmeticException e) { } } } } }
static String longToBinaryString(long L) { StringBuffer sb = new StringBuffer(); for (int i = 0; i < Long.numberOfLeadingZeros(L); i++) { sb.append('0'); } sb.append(Long.toBinaryString(L)); return sb.toString(); }
@Override public long previousClearBit(long fromIndex) { if (fromIndex < 0) { if (fromIndex == NOT_FOUND) return NOT_FOUND; throw new IndexOutOfBoundsException(); } long fromLongIndex = fromIndex >> 6; if (fromLongIndex >= longLength) { fromLongIndex = longLength - 1; fromIndex = size() - 1; } long l = (~bytes.readLong(fromLongIndex << 3)) << ~fromIndex; if (l != 0) return fromIndex - Long.numberOfLeadingZeros(l); for (long i = fromLongIndex - 1; i >= 0; i--) { l = ~bytes.readLong(i << 3); if (l != 0) return (i << 6) + 63 - Long.numberOfLeadingZeros(l); } return NOT_FOUND; }
final void forEachValue(Consumer<? super V> action) { for (long a, tail, allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)), allocIndex = 64 - tail; allocations != 0; allocations <<= 1, allocIndex--) { if (allocations < 0) action.accept(this.<V>readValue(allocIndex)); } }
/** * Answers a double value of d * 2^scaleFactor, the result may be rounded. * * @param d the base number * @param scaleFactor the power number * @return d * 2^scaleFactor * @since 1.6 */ @SuppressWarnings("boxing") public static double scalb(double d, int scaleFactor) { if (Double.isNaN(d) || Double.isInfinite(d) || 0 == d) { return d; } // change double to long for calculation long bits = Double.doubleToLongBits(d); // the sign of the results must be the same of given d long sign = bits & DOUBLE_SIGN_MASK; // calculates the factor of the result long factor = ((bits & DOUBLE_EXPONENT_MASK) >> DOUBLE_MANTISSA_BITS) - DOUBLE_EXPONENT_BIAS + scaleFactor; // calcutes the factor of sub-normal values int subNormalFactor = Long.numberOfLeadingZeros(bits & ~DOUBLE_SIGN_MASK) - DOUBLE_NON_MANTISSA_BITS; if (subNormalFactor < 0) { // not sub-normal values subNormalFactor = 0; } else { factor = factor - subNormalFactor; } if (factor > Double.MAX_EXPONENT) { return (d > 0 ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY); } long result; // if result is a sub-normal if (factor <= -DOUBLE_EXPONENT_BIAS) { // the number of digits that shifts long digits = factor + DOUBLE_EXPONENT_BIAS + subNormalFactor; if (Math.abs(d) < Double.MIN_NORMAL) { // origin d is already sub-normal result = shiftLongBits(bits & DOUBLE_MANTISSA_MASK, digits); } else { // origin d is not sub-normal, change mantissa to sub-normal result = shiftLongBits(bits & DOUBLE_MANTISSA_MASK | 0x0010000000000000L, digits - 1); } } else { if (Math.abs(d) >= Double.MIN_NORMAL) { // common situation result = ((factor + DOUBLE_EXPONENT_BIAS) << DOUBLE_MANTISSA_BITS) | (bits & DOUBLE_MANTISSA_MASK); } else { // origin d is sub-normal, change mantissa to normal style result = ((factor + DOUBLE_EXPONENT_BIAS) << DOUBLE_MANTISSA_BITS) | ((bits << (subNormalFactor + 1)) & DOUBLE_MANTISSA_MASK); } } return Double.longBitsToDouble(result | sign); }
/** * Calculate the number of levels needed for a specific precision. Quadtree cells will not exceed * the specified size (diagonal) of the precision. * * @param meters Maximum size of cells in meters (must greater than zero) * @return levels need to achieve precision */ public static int quadTreeLevelsForPrecision(double meters) { assert meters >= 0; if (meters == 0) { return QuadPrefixTree.MAX_LEVELS_POSSIBLE; } else { final double ratio = 1 + (EARTH_POLAR_DISTANCE / EARTH_EQUATOR); // cell ratio final double width = Math.sqrt((meters * meters) / (ratio * ratio)); // convert to cell width final long part = Math.round(Math.ceil(EARTH_EQUATOR / width)); final int level = Long.SIZE - Long.numberOfLeadingZeros(part) - 1; // (log_2) return (part <= (1l << level)) ? level : (level + 1); // adjust level } }
@Override public long previousSetBit(long fromIndex) { if (fromIndex < 0) { if (fromIndex == NOT_FOUND) return NOT_FOUND; throw new IndexOutOfBoundsException(); } long fromLongIndex = fromIndex >> 6; if (fromLongIndex >= longLength) { // the same policy for this "index out of bounds" situation // as in j.u.BitSet fromLongIndex = longLength - 1; fromIndex = size() - 1; } // << ~fromIndex === << (63 - (fromIndex & 0x3F)) long l = bytes.readLong(fromLongIndex << 3) << ~fromIndex; if (l != 0) return fromIndex - Long.numberOfLeadingZeros(l); for (long i = fromLongIndex - 1; i >= 0; i--) { l = bytes.readLong(i << 3); if (l != 0) return (i << 6) + 63 - Long.numberOfLeadingZeros(l); } return NOT_FOUND; }
final void writeAllEntries(ObjectOutputStream s) throws IOException { for (long a, tail, allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)), allocIndex = 64 - tail; allocations != 0; allocations <<= 1, allocIndex--) { if (allocations < 0) { s.writeObject(readKey(allocIndex)); s.writeObject(readValue(allocIndex)); } } }
final void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) { for (long a, tail, allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)), allocIndex = 64 - tail; allocations != 0; allocations <<= 1, allocIndex--) { if (allocations < 0) { writeValue( allocIndex, function.apply(this.<K>readKey(allocIndex), this.<V>readValue(allocIndex))); } } }
/** * Get the encoded length if an integer is stored in a variable-length format * * @return the encoded length */ public static int getVIntSize(long i) { if (i >= -112 && i <= 127) { return 1; } if (i < 0) { i ^= -1L; // take one's complement' } // find the number of bytes with non-leading zeros int dataBits = Long.SIZE - Long.numberOfLeadingZeros(i); // find the number of data bytes + length byte return (dataBits + 7) / 8 + 1; }
/** * Returns the index of the nearest bit that is set to {@code true} that occurs on or before the * specified starting index. If no such bit exists, or if {@code -1} is given as the starting * index, then {@code -1} is returned. * * @param from the index to start checking from (inclusive) * @return the index of the previous set bit, or {@code -1} if there is no such bit * @throws IndexOutOfBoundsException if the specified index is less than {@code -1} */ public int previousSetBit(int from) { if (from < 0 || from >= size) throw new IndexOutOfBoundsException("index: " + from); int u = wordIndex(from); long word = words[u] & (WORD_MASK >>> -(from + 1)); while (true) { if (word != 0) return (u + 1) * BITS_PER_WORD - 1 - Long.numberOfLeadingZeros(word); if (u-- == 0) return -1; word = words[u]; } }
final boolean forEachWhile(BiPredicate<? super K, ? super V> predicate) { for (long a, tail, allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)), allocIndex = 64 - tail; allocations != 0; allocations <<= 1, allocIndex--) { if (allocations < 0 && !predicate.test(this.<K>readKey(allocIndex), this.<V>readValue(allocIndex))) { return false; } } return true; }
private static boolean isCompressible(byte[] data) { int len = data.length; int[] sum = new int[16]; for (int i = 0; i < len; i++) { int x = (data[i] & 255) >> 4; sum[x]++; } int r = 0; for (int x : sum) { long v = ((long) x << 32) / len; r += 63 - Long.numberOfLeadingZeros(v + 1); } return len * r < len * 120; }
@Override public final int hashCode() { int h = 0; for (long a, tail, allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)), allocIndex = 64 - tail; allocations != 0; allocations <<= 1, allocIndex--) { if (allocations < 0) { h += Objects.hashCode(readKey(allocIndex)) ^ Objects.hashCode(readValue(allocIndex)); } } return h; }
private void or(final int i4096, final long index, long[] bits, int nonZeroLongCount) { assert Long.bitCount(index) == nonZeroLongCount; final long currentIndex = indices[i4096]; if (currentIndex == 0) { // fast path: if we currently have nothing in the block, just copy the data // this especially happens all the time if you call OR on an empty set indices[i4096] = index; this.bits[i4096] = Arrays.copyOf(bits, nonZeroLongCount); this.nonZeroLongCount += nonZeroLongCount; return; } final long[] currentBits = this.bits[i4096]; final long[] newBits; final long newIndex = currentIndex | index; final int requiredCapacity = Long.bitCount(newIndex); if (currentBits.length >= requiredCapacity) { newBits = currentBits; } else { newBits = new long[oversize(requiredCapacity)]; } // we iterate backwards in order to not override data we might need on the next iteration if the // array is reused for (int i = Long.numberOfLeadingZeros(newIndex), newO = Long.bitCount(newIndex) - 1; i < 64; i += 1 + Long.numberOfLeadingZeros(newIndex << (i + 1)), newO -= 1) { // bitIndex is the index of a bit which is set in newIndex and newO is the number of 1 bits on // its right final int bitIndex = 63 - i; assert newO == Long.bitCount(newIndex & ((1L << bitIndex) - 1)); newBits[newO] = longBits(currentIndex, currentBits, bitIndex) | longBits(index, bits, bitIndex); } indices[i4096] = newIndex; this.bits[i4096] = newBits; this.nonZeroLongCount += nonZeroLongCount - Long.bitCount(currentIndex & index); }
final boolean containsValue(SmoothieMap<K, V> map, V value) { V v; for (long a, tail, allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)), allocIndex = 64 - tail; allocations != 0; allocations <<= 1, allocIndex--) { if (allocations < 0) { if (((v = readValue(allocIndex)) == value || (value != null && map.valuesEqual(value, v)))) { return true; } } } return false; }
private Node makeSiblings(Node node, Node sibling) { int parentLevel = MAX_BITS - Long.numberOfLeadingZeros(node.bits ^ sibling.bits); Node parent = createNode(node.bits, parentLevel, 0); // the branch is given by the bit at the level one below parent long branch = sibling.bits & parent.getBranchMask(); if (branch == 0) { parent.left = sibling; parent.right = node; } else { parent.left = node; parent.right = sibling; } return parent; }
/** Writes an unsigned integral to {@code out}. */ public static void writeUnsignedIntegralValue(ByteOutput out, int type, long value) { // Figure out how many bits are needed to represent the value. int requiredBits = 64 - Long.numberOfLeadingZeros(value); if (requiredBits == 0) { requiredBits = 1; } // Round up the requiredBits to a number of bytes. int requiredBytes = (requiredBits + 0x07) >> 3; /* * Write the header byte, which includes the type and * requiredBytes - 1. */ out.writeByte(type | ((requiredBytes - 1) << 5)); // Write the value, per se. while (requiredBytes > 0) { out.writeByte((byte) value); value >>= 8; requiredBytes--; } }
@Test(timeout = 5000L) public void powExactLongIntRandom() { for (int i = 0; i < 100; i++) { long base = RANDOM.nextLong(); for (int j = 0; j < 100; j++) { int power = RANDOM.nextInt(Integer.MAX_VALUE); boolean overflow = BigInteger.valueOf(63 - Long.numberOfLeadingZeros(Math.abs(base))) .multiply(BigInteger.valueOf(power)) .compareTo(BigInteger.valueOf(64)) > 0; BigInteger expected = overflow ? null : BigInteger.valueOf(base).pow(power); if (expected != null && expected.bitLength() <= 63) assertEquals(base + " ^ " + power, expected.longValue(), powExact(base, power)); else { try { powExact(base, power); fail("Should overflow: " + base + " ^ " + power); } catch (ArithmeticException e) { } } } } }