翻译这个Eratosthenes筛网的Java实现？

Question

This is a program in Java which implements the Sieve or Eratosthenes by storing the array of booleans as an array of bits. I have never coded in Java before, but the general idea is easy to understand. However, I cannot understand how the getBit and setBit functions work? I am guessing that the getBit function creates a bitmask with the bit i set to 1 and does bitwise AND between the mask and the array? However, I'm not really understanding the details (eg. why i is right shifted by 4 before being passed as index to array, and why MEMORY_SIZE is equal to MAX right shifted by 4). Please explain the each step of getBit and setBit in words, and if possible an equivalent implementation in Python?

private static final long MAX = 1000000000L;
private static final long SQRT_MAX = (long) Math.sqrt(MAX) + 1;
private static final int MEMORY_SIZE = (int) (MAX >> 4);
private static byte[] array = new byte[MEMORY_SIZE];
//--//
for (long i = 3; i < SQRT_MAX; i += 2) {
  if (!getBit(i)) {
    long j = (i * i);
    while (j < MAX) {
      setBit(j);
      j += (2 * i);
    }
  }
}
//--//
public static boolean getBit(long i) {
  byte block = array[(int) (i >> 4)];
  byte mask = (byte) (1 << ((i >> 1) & 7));
  return ((block & mask) != 0);
}

public static void setBit(long i) {
  int index = (int) (i >> 4);
  byte block = array[index];
  byte mask = (byte) (1 << ((i >> 1) & 7));
  array[index] = (byte) (block | mask);
} 

Answer 1

Some notes in advance:

• (i >> 4) divides i by 16, which is the index of the block (of 8 bits) in array that contains the i -th bit
• (i >> 1) divides i by 2
• 7 in binary code is 111
• ((i >> 1) & 7) means "the three rightmost bits of i / 2 ", which is a number between 0 and 7 (inclusive)
• (1 << ((i >> 1) & 7)) is a bit shifted to the left between 0 and 7 times ( 00000001 , 00000010 , ..., 10000000 ). This is the bit mask to set/get the bit of interest from the selected block.

getBit(i) explained

1. First line selects the 8-bit-block (ie a byte ) in which the bit of interest is located.
2. Second line calculates a bit mask with exactly one bit set. The position of the set bit is the same as the one of the bit of interest within the 8-bit-block.
3. Third line extracts the bit of interest using an bitwise AND, returning true if this bit is 1 .

setBit(i) explained

1. Calculation of the 8-bit-block and the bit mask is equivalent to getBit
2. The difference is that a bitwise OR is used to set the bit of interest.

Edit

To your first question:

It almost makes sense now, can you please explain why we are able to find the position of the bit cooresponding to the number i by shifting a bit left ((i >> 1) & 7) times? In other words, i understand what the operation is doing, but why does this give us the correct bit position?

I think this is because of the optimized nature of the algorithm. Since i is incremented in steps of 2, it is sufficient to use half of the bits (since the others would be set anyway). Thus, i can be divided by 2 to calculate the number of necessary bit shifts.

Regarding your second question:

Also, just to clarify, the reason we increment j by 2*i after each call to setBit is because we only need to set the bits cooresponding to odd multiples of i, right?

Yes, because according to https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes :

Another refinement is to initially list odd numbers only, (3, 5, ..., n), and count in increments of 2p in step 3, thus marking only odd multiples of p.

Your algorithm starts with 3, increments i by 2, and counts in increments of 2*i .

I hope this helps!