How to use

numberOfLeadingZeros

method

in

java.lang.Long

private static int getWriteByteCount(long value)
{
  // if the value is negative flip the bits, so we can always count leading zero bytes
  if (value < 0) {
    value = ~value;
  }
  // count number of leading zero bytes
  return (Long.SIZE - Long.numberOfLeadingZeros(value)) / BITS_IN_BYTE + 1;
}

 static long ceilingPowerOfTwo(long x) {
  // From Hacker's Delight, Chapter 3, Harry S. Warren Jr.
  return 1L << -Long.numberOfLeadingZeros(x - 1);
 }
}

public static int lengthOfSint(long value) {
  int nbBits = 65 - Long.numberOfLeadingZeros(value ^ (value >> 63));
  return (nbBits + 0x07) >> 3;
}

public static int packLong(byte[] buf, int pos, long value){
  int pos2 = pos;
  int shift = 63-Long.numberOfLeadingZeros(value);
  shift -= shift%7; // round down to nearest multiple of 7
  while(shift!=0){
    buf[pos++] = (byte) ((value>>>shift) & 0x7F);
    shift-=7;
  }
  buf[pos++] = (byte) ((value & 0x7F) | 0x80);
  return pos - pos2;
}

/**
 * Returns the product of {@code a} and {@code b} unless it would overflow or underflow in which
 * case {@code Long.MAX_VALUE} or {@code Long.MIN_VALUE} is returned, respectively.
 *
 * @since 20.0
 */
@Beta
public static long saturatedMultiply(long a, long b) {
 // see checkedMultiply for explanation
 int leadingZeros =
   Long.numberOfLeadingZeros(a)
     + Long.numberOfLeadingZeros(~a)
     + Long.numberOfLeadingZeros(b)
     + Long.numberOfLeadingZeros(~b);
 if (leadingZeros > Long.SIZE + 1) {
  return a * b;
 }
 // the return value if we will overflow (which we calculate by overflowing a long :) )
 long limit = Long.MAX_VALUE + ((a ^ b) >>> (Long.SIZE - 1));
 if (leadingZeros < Long.SIZE | (a < 0 & b == Long.MIN_VALUE)) {
  // overflow
  return limit;
 }
 long result = a * b;
 if (a == 0 || result / a == b) {
  return result;
 }
 return limit;
}

/** Returns (a * 2^32) mod m. a may be any unsigned long. */
private long times2ToThe32Mod(long a, long m) {
 int remainingPowersOf2 = 32;
 do {
  int shift = Math.min(remainingPowersOf2, Long.numberOfLeadingZeros(a));
  // shift is either the number of powers of 2 left to multiply a by, or the biggest shift
  // possible while keeping a in an unsigned long.
  a = UnsignedLongs.remainder(a << shift, m);
  remainingPowersOf2 -= shift;
 } while (remainingPowersOf2 > 0);
 return a;
}

/**
 * Returns the largest power of two less than or equal to {@code x}. This is equivalent to {@code
 * checkedPow(2, log2(x, FLOOR))}.
 *
 * @throws IllegalArgumentException if {@code x <= 0}
 * @since 20.0
 */
@Beta
public static long floorPowerOfTwo(long x) {
 checkPositive("x", x);
 // Long.highestOneBit was buggy on GWT.  We've fixed it, but I'm not certain when the fix will
 // be released.
 return 1L << ((Long.SIZE - 1) - Long.numberOfLeadingZeros(x));
}

/**
 * Returns the smallest power of two greater than or equal to {@code x}. This is equivalent to
 * {@code checkedPow(2, log2(x, CEILING))}.
 *
 * @throws IllegalArgumentException if {@code x <= 0}
 * @throws ArithmeticException of the next-higher power of two is not representable as a {@code
 *     long}, i.e. when {@code x > 2^62}
 * @since 20.0
 */
@Beta
public static long ceilingPowerOfTwo(long x) {
 checkPositive("x", x);
 if (x > MAX_SIGNED_POWER_OF_TWO) {
  throw new ArithmeticException("ceilingPowerOfTwo(" + x + ") is not representable as a long");
 }
 return 1L << -Long.numberOfLeadingZeros(x - 1);
}

Long.numberOfLeadingZeros(a)
  + Long.numberOfLeadingZeros(~a)
  + Long.numberOfLeadingZeros(b)
  + Long.numberOfLeadingZeros(~b);

/** Returns (a * 2^32) mod m. a may be any unsigned long. */
private long times2ToThe32Mod(long a, long m) {
 int remainingPowersOf2 = 32;
 do {
  int shift = Math.min(remainingPowersOf2, Long.numberOfLeadingZeros(a));
  // shift is either the number of powers of 2 left to multiply a by, or the biggest shift
  // possible while keeping a in an unsigned long.
  a = UnsignedLongs.remainder(a << shift, m);
  remainingPowersOf2 -= shift;
 } while (remainingPowersOf2 > 0);
 return a;
}

/**
 * Returns base 2 logarithm of the closest power of 2 that is less or equal to the {@code value}.
 *
 * @param value a positive long value
 */
public static int log2floor( long value )
{
  return (Long.SIZE - 1) - Long.numberOfLeadingZeros( requirePositive( value ) );
}

/** Returns (a * 2^32) mod m. a may be any unsigned long. */
private long times2ToThe32Mod(long a, long m) {
 int remainingPowersOf2 = 32;
 do {
  int shift = Math.min(remainingPowersOf2, Long.numberOfLeadingZeros(a));
  // shift is either the number of powers of 2 left to multiply a by, or the biggest shift
  // possible while keeping a in an unsigned long.
  a = UnsignedLongs.remainder(a << shift, m);
  remainingPowersOf2 -= shift;
 } while (remainingPowersOf2 > 0);
 return a;
}

/**
 * Returns an integer X such that 2^X=value. Throws an exception
 * if value is not a power of 2.
 *
 * @param value
 * @return
 */
public static int getPowerOf2(long value) {
  Preconditions.checkArgument(isPowerOf2(value));
  return Long.SIZE-(Long.numberOfLeadingZeros(value)+1);
}

/**
 * Returns the largest power of two less than or equal to {@code x}. This is equivalent to {@code
 * checkedPow(2, log2(x, FLOOR))}.
 *
 * @throws IllegalArgumentException if {@code x <= 0}
 * @since 20.0
 */
@Beta
public static long floorPowerOfTwo(long x) {
 checkPositive("x", x);
 // Long.highestOneBit was buggy on GWT.  We've fixed it, but I'm not certain when the fix will
 // be released.
 return 1L << ((Long.SIZE - 1) - Long.numberOfLeadingZeros(x));
}

public void packLong(long value) {
  ensureAvail(10); //ensure worst case bytes
  int shift = 63-Long.numberOfLeadingZeros(value);
  shift -= shift%7; // round down to nearest multiple of 7
  while(shift!=0){
    buf[pos++] = (byte) ((value>>>shift) & 0x7F);
    shift-=7;
  }
  buf[pos++] = (byte) ((value & 0x7F) | 0x80);
}

@GwtIncompatible // TODO
static int log10Floor(long x) {
 /*
  * Based on Hacker's Delight Fig. 11-5, the two-table-lookup, branch-free implementation.
  *
  * The key idea is that based on the number of leading zeros (equivalently, floor(log2(x))), we
  * can narrow the possible floor(log10(x)) values to two. For example, if floor(log2(x)) is 6,
  * then 64 <= x < 128, so floor(log10(x)) is either 1 or 2.
  */
 int y = maxLog10ForLeadingZeros[Long.numberOfLeadingZeros(x)];
 /*
  * y is the higher of the two possible values of floor(log10(x)). If x < 10^y, then we want the
  * lower of the two possible values, or y - 1, otherwise, we want y.
  */
 return y - lessThanBranchFree(x, powersOf10[y]);
}

 return (Long.SIZE - 1) - Long.numberOfLeadingZeros(x);
 return Long.SIZE - Long.numberOfLeadingZeros(x - 1);
case HALF_EVEN:
 int leadingZeros = Long.numberOfLeadingZeros(x);
 long cmp = MAX_POWER_OF_SQRT2_UNSIGNED >>> leadingZeros;

/**
 * Returns the smallest power of two greater than or equal to {@code x}. This is equivalent to
 * {@code checkedPow(2, log2(x, CEILING))}.
 *
 * @throws IllegalArgumentException if {@code x <= 0}
 * @throws ArithmeticException of the next-higher power of two is not representable as a {@code
 *     long}, i.e. when {@code x > 2^62}
 * @since 20.0
 */
@Beta
public static long ceilingPowerOfTwo(long x) {
 checkPositive("x", x);
 if (x > MAX_SIGNED_POWER_OF_TWO) {
  throw new ArithmeticException("ceilingPowerOfTwo(" + x + ") is not representable as a long");
 }
 return 1L << -Long.numberOfLeadingZeros(x - 1);
}

/**
 * Returns the largest power of two less than or equal to {@code x}. This is equivalent to {@code
 * checkedPow(2, log2(x, FLOOR))}.
 *
 * @throws IllegalArgumentException if {@code x <= 0}
 * @since 20.0
 */
@Beta
public static long floorPowerOfTwo(long x) {
 checkPositive("x", x);
 // Long.highestOneBit was buggy on GWT.  We've fixed it, but I'm not certain when the fix will
 // be released.
 return 1L << ((Long.SIZE - 1) - Long.numberOfLeadingZeros(x));
}

@GwtIncompatible // TODO
static int log10Floor(long x) {
 /*
  * Based on Hacker's Delight Fig. 11-5, the two-table-lookup, branch-free implementation.
  *
  * The key idea is that based on the number of leading zeros (equivalently, floor(log2(x))), we
  * can narrow the possible floor(log10(x)) values to two. For example, if floor(log2(x)) is 6,
  * then 64 <= x < 128, so floor(log10(x)) is either 1 or 2.
  */
 int y = maxLog10ForLeadingZeros[Long.numberOfLeadingZeros(x)];
 /*
  * y is the higher of the two possible values of floor(log10(x)). If x < 10^y, then we want the
  * lower of the two possible values, or y - 1, otherwise, we want y.
  */
 return y - lessThanBranchFree(x, powersOf10[y]);
}