大约一年前，我在为c ++ 11实现无序（哈希）容器时为libc ++工作。我以为我会在这里分享我的经验。这种经验支持marcog对“蛮力”的
合理定义的公认答案。
这意味着在大多数情况下，即使是简单的蛮力也足够快，平均取O（ln（p）* sqrt（p））。
我开发了几种实现size_t next_prime(size_t n)此功能的规范的实现：
返回： 大于或等于的最小素数n。
的每个实现next_prime都带有辅助功能is_prime。 is_prime应被视为私人实施细节；不能直接由客户调用。这些实现中的每一个当然都经过了正确性测试，但还通过以下性能测试进行了测试：
int main()
{
typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::duration<double, std::milli> ms;
Clock::time_point t0 = Clock::now();
std::size_t n = 100000000;
std::size_t e = 100000;
for (std::size_t i = 0; i < e; ++i)
n = next_prime(n+1);
Clock::time_point t1 = Clock::now();
std::cout << e/ms(t1-t0).count() << " primes/millisecond\n";
return n;
}
我应该强调，这是一项性能测试，并不反映典型的用法，看起来更像是：
// Overflow checking not shown for clarity purposes
n = next_prime(2*n + 1);
所有性能测试均使用以下命令进行编译：
clang++ -stdlib=libc++ -O3 main.cpp
实施1
有七个实现。显示第一个实现的目的是证明，如果您没有停止测试候选素数x的因子，sqrt(x)那么您甚至都无法实现可以归为蛮力的实现。此实现
速度很慢。
bool
is_prime(std::size_t x)
{
if (x < 2)
return false;
for (std::size_t i = 2; i < x; ++i)
{
if (x % i == 0)
return false;
}
return true;
}
std::size_t
next_prime(std::size_t x)
{
for (; !is_prime(x); ++x)
;
return x;
}
对于此实现e，仅为了获得合理的运行时间，我必须将其设置为100而不是100000：
0.0015282 primes/millisecond
实施2
此实现是蛮力实现中最慢的，并且与实现1的唯一区别是，当因子超过时，它将停止测试素数sqrt(x)。
bool
is_prime(std::size_t x)
{
if (x < 2)
return false;
for (std::size_t i = 2; true; ++i)
{
std::size_t q = x / i;
if (q < i)
return true;
if (x % i == 0)
return false;
}
return true;
}
std::size_t
next_prime(std::size_t x)
{
for (; !is_prime(x); ++x)
;
return x;
}
请注意，sqrt(x)它不是直接计算出来的，而是由推断出来的q < i。这样可以使速度加快数千倍：
5.98576 primes/millisecond
并验证了marcog的预测：
...这完全在大多数问题的约束范围内，而大多数现代硬件上的问题大约需要毫秒。
实施3
通过避免使用%运算符，可以使速度提高近一倍（至少在我使用的硬件上）：
bool
is_prime(std::size_t x)
{
if (x < 2)
return false;
for (std::size_t i = 2; true; ++i)
{
std::size_t q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
}
return true;
}
std::size_t
next_prime(std::size_t x)
{
for (; !is_prime(x); ++x)
;
return x;
}
11.0512 primes/millisecond
实施4
到目前为止，我什至没有使用常识，即2是唯一的偶数素数。此实现结合了这些知识，速度几乎翻了一番：
bool
is_prime(std::size_t x)
{
for (std::size_t i = 3; true; i += 2)
{
std::size_t q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
}
return true;
}
std::size_t
next_prime(std::size_t x)
{
if (x <= 2)
return 2;
if (!(x & 1))
++x;
for (; !is_prime(x); x += 2)
;
return x;
}
21.9846 primes/millisecond
实施4可能是大多数人认为“蛮力”的想法。
实施5
使用以下公式，您可以轻松选择所有不能被2或3整除的数字。
6 * k + {1, 5}
其中k> =1。以下实现使用此公式，但使用可爱的xor技巧实现：
bool
is_prime(std::size_t x)
{
std::size_t o = 4;
for (std::size_t i = 5; true; i += o)
{
std::size_t q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
o ^= 6;
}
return true;
}
std::size_t
next_prime(std::size_t x)
{
switch (x)
{
case 0:
case 1:
case 2:
return 2;
case 3:
return 3;
case 4:
case 5:
return 5;
}
std::size_t k = x / 6;
std::size_t i = x - 6 * k;
std::size_t o = i < 2 ? 1 : 5;
x = 6 * k + o;
for (i = (3 + o) / 2; !is_prime(x); x += i)
i ^= 6;
return x;
}
这实际上意味着该算法只需要检查1/3的整数的素数，而不是数字的1/2，性能测试表明预期的速度提高了近50％：
32.6167 primes/millisecond
实施6
此实现是实现5的逻辑扩展：它使用以下公式计算不能被2、3和5整除的所有数字：
30 * k + {1, 7, 11, 13, 17, 19, 23, 29}
它还展开is_prime内的内部循环，并创建一个“小素数”列表，该列表对于处理小于30的数字很有用。
static const std::size_t small_primes[] =
{
2,
3,
5,
7,
11,
13,
17,
19,
23,
29
};
static const std::size_t indices[] =
{
1,
7,
11,
13,
17,
19,
23,
29
};
bool
is_prime(std::size_t x)
{
const size_t N = sizeof(small_primes) / sizeof(small_primes[0]);
for (std::size_t i = 3; i < N; ++i)
{
const std::size_t p = small_primes[i];
const std::size_t q = x / p;
if (q < p)
return true;
if (x == q * p)
return false;
}
for (std::size_t i = 31; true;)
{
std::size_t q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 6;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 4;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 2;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 4;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 2;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 4;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 6;
q = x / i;
if (q < i)
return true;
if (x == q * i)
return false;
i += 2;
}
return true;
}
std::size_t
next_prime(std::size_t n)
{
const size_t L = 30;
const size_t N = sizeof(small_primes) / sizeof(small_primes[0]);
// If n is small enough, search in small_primes
if (n <= small_primes[N-1])
return *std::lower_bound(small_primes, small_primes + N, n);
// Else n > largest small_primes
// Start searching list of potential primes: L * k0 + indices[in]
const size_t M = sizeof(indices) / sizeof(indices[0]);
// Select first potential prime >= n
// Known a-priori n >= L
size_t k0 = n / L;
size_t in = std::lower_bound(indices, indices + M, n - k0 * L) - indices;
n = L * k0 + indices[in];
while (!is_prime(n))
{
if (++in == M)
{
++k0;
in = 0;
}
n = L * k0 + indices[in];
}
return n;
}
可以说，这超出了“蛮力”，并且有利于将速度再提高27.5％，从而达到：
41.6026 primes/millisecond
实施7
反复玩上面的游戏是很实际的，为不能被2、3、5和7整除的数字建立一个公式：
210 * k + {1, 11, ...},
源代码未在此处显示，但与实现6非常相似。这是我选择实际用于libc ++的无序容器的实现，并且该源代码是开源的（可在链接中找到）。
最后的迭代有利于将速度进一步提高14.6％，以：
47.685 primes/millisecond
使用此算法可确保libc ++哈希表的客户端可以选择自己决定的任何素数，这对他们的情况最有利，并且此应用程序的性能是可以接受的。
