Comparability between implementations about primes

[flo80]

Considerations for a solution

Ok I don't really have a solution, but here are some of my considerations:

• Constructs and optimizations that a language provides are fine and wanted (for example using iterators / filters in rust instead of the normal for loops, or C++ vector find) since those represent the languages features
• The base algorithm should have to be the same if any cross language comparison is wanted (outer loop, find next factor, set values for this factor, increment factor)
• The factor checking HAS to start with 3 and not 5, 7, or even higher to stay comparable
• The way how the smaller tasks in the algorithm, like setting / clearing or storing the values can be changed as needed

Well this would exactly be my understanding of the rules in CONTRIBUTING.md. If an implementation wants to be base, it has to use the algorithm as in the original solution and it has to start checking at 3. If it want's to be faithful it also has to stick to some memory management rules.

So a comparison of results using base and being faithful should still be valid I think.

[rbergen]

So a comparison of results using base and being faithful should still be valid I think.

On top of that, Dave's leaderboard will only include solutions that use 1 bit per prime candidate.

[sglienke]

I think what's considered faithful and what not is a bit of a nitpick when it comes to some details.
The space for the storage for example can be halfed without changing the algorithm itself and goes in line with the inc by 2 loop. When even numbers are not even counted except 2 then why put them into the sieve at all.

Also the fact that vector<bool> is implemented as bitpacked storage and the C++ compilers know about that is an implementation detail and should not force other implementations to do the same - whether this fact even matters highly depends on your L1 cache size and the bit-twiddling can even be detrimental for performance.

[rbergen]

This is also my response to your comment on #398: the rules are indeed somewhat arbitrary. They're based on a) the 3 implementations that started this project, and b) what Dave has explicitly indicated is important to him (bit twiddling is one of them). They've been in place for a while now, and they've served us to the point that there are now well over 100 implementations in 53 languages in this repo dealing with them.