Question

this is the numberOfLeadingZeros(long i) in Long.java :

public static int numberOfLeadingZeros(long i) {
        // HD, Figure 5-6
         if (i == 0)
            return 64;
        int n = 1;
        int x = (int)(i >>> 32);
        if (x == 0) { n += 32; x = (int)i; }
        if (x >>> 16 == 0) { n += 16; x <<= 16; }
        if (x >>> 24 == 0) { n +=  8; x <<=  8; }
        if (x >>> 28 == 0) { n +=  4; x <<=  4; }
        if (x >>> 30 == 0) { n +=  2; x <<=  2; }
        n -= x >>> 31;
        return n;
}

and the author said it is based floor(log2(x)) = 63 – numberOfLeadingZeros(x) or ceil(log2(x)) = 64 – numberOfLeadingZeros(x – 1),is that true? or maybe i am so stupid that can’t understand?

somebody who can explain it to me? thanks!

Answer 1

The number of digits in a number is floor(log(num)) + 1 (with log in the correct base.) If the total digit space is x, then the number of leading zeros is

x - (floor(log(num)) + 1) =
(x - 1) - floor(log(num))

So in your case, with 64 total digits and the number in binary

leadingZeros(num) = 63 - floor(log_2(num))

Edit:

>>> is the unsigned right shift operator in Java and << is a left shift. n >>> 32 will shift n 32 bits to the right while filling the empty space with 0s.

So the algorithm works as follows:

0000000000000000000000000000000000000000000001011010100000101011

1. Shift i 32 bits to the right so x contains only the upper 32 bits.

   00000000000000000000000000000000

2. If (a) this is 0, we know the upper 32 bits were 0s so add 32 to the leading zero count and concentrate on the lower 32 bits. (b) Otherwise, this is nonzero so the number has less than 32 leading zeros. Concentrate on the upper 32 bits.

3. Shift x 16 bits to the right.

   0000000000000101

   By the same process: (a) If this is 0, add 16 to the leading zero count and concentrate on the next lowest 16 bits (by shifting them left into the area where we’re working.) (b) If this is nonzero, then we have less than 16 leading zeros to add.

4. Repeat for the next byte, then the next 4 bits, 2 bits, and the final bit.