primesieve

*Update:* While validating TSE against primesieve, I discovered consistent ±1 counting discrepancies at 10^13 scale. The findings point to a classic edge-case bug in segmented sieve algorithms. Details: https://github.com/kimwalisch/primesieve/issues/178 Would appreciate feedback from the community!

This is a fascinating Q&A where user GordonBGood analyzes the performance of the Sieve of Atkin and compares it to that of Eratosthenes with a view to practical implementations. The fast prime generator project primesieve is also relevant: https://github.com/kimwalisch/primesieve

This is really elegant! To make the explanation more concrete, here's a snapshot of the algorithm's state (the dict D) after it has processed numbers up to 10 (inclusive): 12: [3, 2] 25: [5] 49: [7] So each prime up to 10 is present exactly once. When we process 12, we move 2 to the list for 14, and 3 to the list for 15. The Sorenson paper linked in the post is also a great read, I remember reading it a couple of years ago and it is very clear. It adds many further optimizations on top of standard sieve of Eratosthenes (e.g. wheel factorization is a generalization of the idea of considering only numbers in {1, 5} mod 6, or {1, 7, 11, 13, 17, 19, 23, 29} mod 30, or …), and segmenting is what you need to do to avoid running out of memory. The fastest such generator (using sieve-based methods) seems to be https://github.com/kimw

There is a very beautiful way to do it using much less memory. You need O(sqrt(n)/log(n)) memory, not O(n), if you keep track of the list of primes found so far, and a fixed-size interval over which you sieve: [1, k], [k+1, 2k], [2k+1, 3k], ... Now, for the beautiful part, if you skip multiples of 2, 3 and 5, and work in blocks of 2 * 3 * 5 = 30 numbers, you only need to sieve {1, 7, 11, 13, 17, 19, 23, 29} + i*30. 8 booleans, that happen to fit in 1 byte. So 1 byte = 1 interval of 30 numbers. Next, you can unroll the sieving loop, but no compiler will do this for you, you have to do it by hand. This allows you to sieve up to 8 multiples per iteration. I have an implementation of it in Julia here: https://github.com/haampie/FastPrimeSieve.jl which was influenced by https://github.com/kimwalisch/primesieve.

I've recently ported the primesieve.org algorithm outlined to Go: https://github.com/caleblloyd/primesieve The algorithm runs pretty fast, but primesieve.org's C version of the program still runs orders of magnitude faster than the Go port that I wrote. Does anyone have ideas of how to bridge the performance gap so that this Go implementation performs closer to that of the C version supplied by primesieve.org? Or is the slowdown simply the result of running in a Garbage Collected language? Primesieve.org segmented sieve algorithm outline: http://primesieve.org/segmented_sieve.html Primesieve.org performance times: http://primesieve.org/ Primesieve.org C Source on GitHub: https://github.com/kimwalisch/primesieve