埃拉托色尼筛 - 按位优化问题

Question

我想你们每个人都遇到过 Eratosthenes sieve 的按位运算优化代码。我试图绕开它，我对这个实现中的一个操作有疑问。以下是 GeeksforGeeks 的代码：

bool ifnotPrime(int prime[], int x) { 
    // checking whether the value of element 
    // is set or not. Using prime[x/64], we find 
    // the slot in prime array. To find the bit 
    // number, we divide x by 2 and take its mod 
    // with 32. 
    return (prime[x / 64] & (1 << ((x >> 1) & 31))); 
} 

// Marks x composite in prime[] 
bool makeComposite(int prime[], int x) { 
    // Set a bit corresponding to given element. 
    // Using prime[x/64], we find the slot in prime  
    // array. To find the bit number, we divide x 
    // by 2 and take its mod with 32. 
    prime[x / 64] |= (1 << ((x >> 1) & 31)); 
} 

// Prints all prime numbers smaller than n. 
void bitWiseSieve(int n) { 
    // Assuming that n takes 32 bits, we reduce 
    // size to n/64 from n/2. 
    int prime[n / 64]; 

    // Initializing values to 0 . 
    memset(prime, 0, sizeof(prime)); 

    // 2 is the only even prime so we can ignore that 
    // loop starts from 3 as we have used in sieve of 
    // Eratosthenes . 
    for (int i = 3; i * i <= n; i += 2) { 

        // If i is prime, mark all its multiples as 
        // composite 
        if (!ifnotPrime(prime, i)) 
            for (int j = i * i, k = i << 1; j < n; j += k) 
                makeComposite(prime, j); 
    } 

    // writing 2 separately 
    printf("2 "); 

    // Printing other primes 
    for (int i = 3; i <= n; i += 2) 
        if (!ifnotPrime(prime, i)) 
            printf("%d ", i); 
} 

// Driver code 
int main() { 
    int n = 30; 
    bitWiseSieve(n); 
    return 0; 
} 

所以我的问题是：

1. (prime[x/64] & (1 << ((x >> 1) & 31)) 更具体地说是(1 << ((x >> 1) & 31)); 是什么意思
2. 在 prime[x/64] 中，当我们使用 32 位整数时，为什么要除以 64 而不是 32；
3. 如果n < 64，int prime[n/64] 是否正确？

Answer 1

代码中存在多个问题：

• makeComposite() 应该有返回类型 void。
• 如果x == 63 (1 << ((x >> 1) & 31)) 具有未定义的行为，因为1 << 31 溢出了int 类型的范围。您应该使用1U 或最好使用1UL 来确保32 位。
• 移动表项并屏蔽最后一位会更简单：return (prime[x / 64] >> ((x >> 1) & 31)) & 1;
• 不要假设类型int 有32 位，而应该使用uint32_t 作为位数组的类型。
• 如果n 不是64 的倍数，则数组int prime[n / 64]; 太短。请改用uint32_t prime[n / 64 + 1];。这是您的示例n = 30 的问题，因此创建的数组长度为0。
• ifnotPrime(n) 仅返回奇数值的有效结果。更改此函数并将其命名为 isOddPrime() 可能会更好、更易读。

关于您的问题：

(prime[x/64] & (1 << ((x >> 1) & 31)) 更具体地说是(1 << ((x >> 1) & 31)) 是什么意思？

x 首先除以 2（右移一位），因为数组中只有奇数有一个位，然后将结果用 31 屏蔽，以保持 5 个低位作为字中的位数。对于任何无符号值x，x & 31 等价于x % 32。 x / 64 是测试该位的字号。

如上所述，1 是 int，因此不应向左移动 31 个位置。使用1UL 可确保该类型至少有 32 位，并且可以移动 31 个位置。

在 prime[x/64] 中，当我们使用 32 位整数时，为什么要除以 64 而不是 32？

数组中的位对应于奇数，因此一个 32 位的字包含 64 个数字的素数信息：32 个已知为合数的偶数和 32 个奇数，如果该数字为合成的。

如果n < 64，int prime[n/64] 是否正确？

不是不是，如果n不是64的倍数是不正确的：大小表达式应该是(n + 63) / 64，或者更好的是int prime[n/64 + 1]

---

这是一个修改版本，您可以在其中传递命令行参数：

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

bool isOddPrime(const uint32_t prime[], unsigned x) {
    // checking whether the value of element
    // is set or not. Using prime[x/64], we find
    // the slot in prime array. To find the bit
    // number, we divide x by 2 and take its mod
    // with 32.
    return 1 ^ ((prime[x / 64] >> ((x >> 1) & 31)) & 1);
}

// Marks x composite in prime[]
void makeComposite(uint32_t prime[], unsigned x) {
    // Set a bit corresponding to given element.
    // Using prime[x/64], we find the slot in prime
    // array. To find the bit number, we divide x
    // by 2 and take its mod with 32.
    prime[x / 64] |= (1UL << ((x >> 1) & 31));
}

// Prints all prime numbers smaller than n.
void bitWiseSieve(unsigned n) {
    // Assuming that n takes 32 bits, we reduce
    // size to n/64 from n/2.
    uint32_t prime[n / 64 + 1];

    // Initializing values to 0 .
    memset(prime, 0, sizeof(prime));

    // 2 is the only even prime so we can ignore that
    // loop starts from 3 as we have used in sieve of
    // Eratosthenes .
    for (unsigned i = 3; i * i <= n; i += 2) {
        // If i is prime, mark all its multiples as composite
        if (isOddPrime(prime, i)) {
            for (unsigned j = i * i, k = i << 1; j < n; j += k)
                makeComposite(prime, j);
        }
    }

    // writing 2 separately
    if (n >= 2)
        printf("2\n");

    // Printing other primes
    for (unsigned i = 3; i <= n; i += 2) {
        if (isOddPrime(prime, i))
            printf("%u\n", i);
    }
}

// Driver code
int main(int argc, char *argv[]) {
    unsigned n = argc > 1 ? strtol(argv[1], NULL, 0) : 1000;
    bitWiseSieve(n);
    return 0;
}

Answer 2

1)x%32 等价于x&31：逻辑且在最低有效 5 位上。所以基本上((x>>1)&31) 暗示((x/2)%32)。而1<<x 表示2^x 所以你要问的是2^((x/2)%32)。

2) 实现中的一个优化是，它完全跳过了所有偶数。

3)n可以小于64