title: C++ Sieve of Atkin overlooks a few prime numbers
body: <p>Recently I've been working on a C++ prime generator that uses the Sieve of Atkin ( <a href="http://en.wikipedia.org/wiki/Sieve_of_atkin" rel="nofollow noreferrer">http://en.wikipedia.org/wiki/Sieve_of_atkin</a> ) to generate its primes.  My objective is to be able to generate any 32-bit number.  I'll use it mostly for project euler problems.  mostly it's just a summer project.</p>
  
  <p>The program uses a bitboard to store primality:  that is, a series of ones and zeros where for example the 11th bit would be a 1, the 12th a 0, and the 13th a 1, etc.  For efficient memory usage, this is actually and array of chars, each char containing 8 bits.  I use flags and bitwise-operators to set and retrieve bits.  The gyst of the algorithm is simple:  do a first pass using some equations I don't pretend to understand to define if a number is considered "prime" or not.  This will for the most part get the correct answers, but a couple nonprime numbers will be marked as prime.  Therefore, when iterating through the list, you set all multiples of the prime you just found to "not prime".  This has the handy advantage of requiring less processor time the larger a prime gets.</p>
  
  <p>I've got it 90% complete, with one catch:
  some of the primes are missing.  </p>
  
  <p>Through inspecting the bitboard, I have ascertained that these primes are omitted during the first pass, which basically toggles a number for every solution it has for a number of equations (see wikipedia entry).  I've gone over this chunk of code time and time again.  I even tried increasing the bounds to what is shown in the wikipedia articles, which is less efficient but I figured might hit a few numbers that I have somehow omitted.  Nothing has worked.  These numbers simply evaluate to not prime.  Most of my test has been on all primes under 128. Of this range, these are the primes that are omitted:</p>
  
  <p>23 and 59.</p>
  
  <p>I have no doubt that on a higher range, more would be missing (just don't want to count through all of them).  I don't know why these are missing, but they are.  Is there anything special about these two primes?  I've double and triple checked, finding and fixing mistakes, but it is still probably something stupid that I am missing.</p>
  
  <p>anyways, here is my code:</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;limits.h&gt;
  #include &lt;math.h&gt;
  
  using namespace std;
  
  const unsigned short DWORD_BITS = 8;
  
  unsigned char flag(const unsigned char);
  void printBinary(unsigned char);
  
  
  class PrimeGen
  {
      public:
          unsigned char* sieve;
          unsigned sievelen;
          unsigned limit;
          unsigned bookmark;
  
  
          PrimeGen(const unsigned);
  
          void firstPass();
          unsigned next();
  
          bool getBit(const unsigned);
          void onBit(const unsigned);
          void offBit(const unsigned);
          void switchBit(const unsigned);
  
          void printBoard();
  };
  
  
  PrimeGen::PrimeGen(const unsigned max_num)
  {
      limit = max_num;
      sievelen = limit / DWORD_BITS + 1;
      bookmark = 0;
  
      sieve = (unsigned char*) malloc(sievelen);
      for (unsigned i = 0; i &lt; sievelen; i++) {sieve[i] = 0;}
  
      firstPass();
  }
  
  
  inline bool PrimeGen::getBit(const unsigned index)
  {
      return sieve[index/DWORD_BITS] &amp; flag(index%DWORD_BITS);
  }
  
  
  inline void PrimeGen::onBit(const unsigned index)
  {
      sieve[index/DWORD_BITS] |= flag(index%DWORD_BITS);
  }
  
  
  inline void PrimeGen::offBit(const unsigned index)
  {
      sieve[index/DWORD_BITS] &amp;= ~flag(index%DWORD_BITS);
  }
  
  
  inline void PrimeGen::switchBit(const unsigned index)
  {
      sieve[index/DWORD_BITS] ^= flag(index%DWORD_BITS);
  }
  
  
  void PrimeGen::firstPass()
  {
      unsigned nmod,n,x,y,xroof, yroof;
  
      //n = 4x^2 + y^2
      xroof = (unsigned) sqrt(((double)(limit - 1)) / 4);
      for(x = 1; x &lt;= xroof; x++){
          yroof = (unsigned) sqrt((double)(limit - 4 * x * x));
          for(y = 1; y &lt;= yroof; y++){
              n = (4 * x * x) + (y * y);
              nmod = n % 12;
              if (nmod == 1 || nmod == 5){
                  switchBit(n);
              }
          }
      }
  
      xroof = (unsigned) sqrt(((double)(limit - 1)) / 3);
      for(x = 1; x &lt;= xroof; x++){
          yroof = (unsigned) sqrt((double)(limit - 3 * x * x));
          for(y = 1; y &lt;= yroof; y++){
              n = (3 * x * x) + (y * y);
              nmod = n % 12;
              if (nmod == 7){
                  switchBit(n);
              }
          }
      }
  
      xroof = (unsigned) sqrt(((double)(limit + 1)) / 3);
      for(x = 1; x &lt;= xroof; x++){
          yroof = (unsigned) sqrt((double)(3 * x * x - 1));
          for(y = 1; y &lt;= yroof; y++){
              n = (3 * x * x) - (y * y);
              nmod = n % 12;
              if (nmod == 11){
                  switchBit(n);
              }
          }
      }
  }
  
  
  unsigned PrimeGen::next()
  {
      while (bookmark &lt;= limit)
      {
          bookmark++;
  
          if (getBit(bookmark))
          {
              unsigned out = bookmark;
  
              for(unsigned num = bookmark * 2; num &lt;= limit; num += bookmark)
              {
                  offBit(num);
              }
  
              return out;
          }
      }
  
      return 0;
  }
  
  
  inline void PrimeGen::printBoard()
  {
      for(unsigned i = 0; i &lt; sievelen; i++)
      {
          if (i % 4 == 0)
              cout &lt;&lt; endl;
  
          printBinary(sieve[i]);
          cout &lt;&lt; " ";
      }
  }
  
  
  inline unsigned char flag(const unsigned char bit_index)
  {
      return ((unsigned char) 128) &gt;&gt; bit_index;
  }
  
  
  inline void printBinary(unsigned char byte)
  {
      unsigned int i = 1 &lt;&lt; (sizeof(byte) * 8 - 1);
  
      while (i &gt; 0) {
          if (byte &amp; i)
              cout &lt;&lt; "1";
          else
              cout &lt;&lt; "0";
          i &gt;&gt;= 1;
      }
  }
  </code></pre>
  
  <p>I did my best to clean it up and make it readable.  I'm not a professional programmer, so please be merciful.</p>
  
  <p>Here is the output I get, when I initialize a PrimeGen object named pgen, print its initial bitboard with pgen.printBoard() (please note that 23 and 59 are missing before next() iteration), and then iterate through next() and print all of the returned primes:</p>
  
  <pre><code>00000101 00010100 01010000 01000101
  00000100 01010001 00000100 00000100
  00010001 01000001 00010000 01000000
  01000101 00010100 01000000 00000001
  
  5
  7
  11
  13
  17
  19
  29
  31
  37
  41
  43
  47
  53
  61
  67
  71
  73
  79
  83
  89
  97
  101
  103
  107
  109
  113
  127
  
  DONE
  
  Process returned 0 (0x0)   execution time : 0.064 s
  Press any key to continue.
  </code></pre>