Improvements for isPrime function - c++

Question

There are many problems on the internet that require you to find prime numbers, so I decided to write a set of functions to find them. I used the Sieve of Eratosthenes for generating the primes as it was fast and easy to implement compared to other algorithms. However, I'm wondering if my code rather than my method is inefficient. Am I using STL containers/iterators right? Is there any section in my code slowing down the program?
In other words it does calculate the results correctly, but what I wonder about is whether its efficiency can be improved by some algorithmic improvement as opposed to just some code tweaking.
Any help is truly appreciated.
Here's my code
(I apologize if it's hard to read)
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
#define initial_prime_barrier 100
bool isFlagged(int i) { return i == 0; }
bool isNextStart(int i) { return i != 0; }
vector<int> generatePrimesBelow(int limit)
{
vector<int> primes;
for (int i = 2; i < limit; i++)
{
primes.push_back(i);
}
vector<int>::iterator currentStart = primes.begin();
do
{
int numberAtStart = *currentStart;
vector<int>::iterator currentNumber = currentStart + numberAtStart;
do
{
*currentNumber = 0;
advance(currentNumber, numberAtStart);
} while (currentNumber < primes.end());
currentStart = find_if(currentStart + 1, primes.end(), isNextStart);
} while ((*currentStart) * (*currentStart) < limit);
vector<int>::iterator newEnd = remove_if(primes.begin(), primes.end(), isFlagged);
primes.erase(newEnd, primes.end());
return primes;
}
bool isPrime(int number)
{
static vector<int> primes = generatePrimesBelow(initial_prime_barrier);
static int numPrimes = primes.size();
static int largestPrime = primes[numPrimes-1];
static int halfwayPrime = primes[numPrimes/2];
if (number == largestPrime)
{
return true;
}
else if (number < largestPrime)
{
if (number == halfwayPrime)
{
return true;
}
else if (number > halfwayPrime)
{
for (int i = numPrimes/2; i < numPrimes; i++)
{
if (number == primes[i])
{
return true;
}
}
}
else if (number < halfwayPrime)
{
for (int i = numPrimes/2; i >= 0; i--)
{
if (number == primes[i])
{
return true;
}
}
}
}
else if (number > largestPrime)
{
primes = generatePrimesBelow(number + number);
numPrimes = primes.size();
largestPrime = primes[numPrimes-1];
halfwayPrime = primes[numPrimes/2];
return isPrime(number);
}
return false;
}
int main (int argc, char * const argv[])
{
const int number = 123123;
cout << (isPrime(number) ? "YES" : "NO") << endl;
}

Answer 1

Yes, it is your method. Several things. You don't need your array to hold numbers, each entry's address in the array is the number itself. You just need them to hold two values - true and false. So make your array vector<bool>, it will be much more compact. Then, in your inner loop you start from x+x and advance by steps of x. You should start from x*x, and advance by steps of 2*x - that will work for all x except 2. Make it a special case, or mark these even numbers at the initialization loop. Or treat an entry at i as representing the number 2*i+1 and dispense with handling evens altogether. This should speed up your sieve code. Lastly, you don't need special find_if call with all its machinery, you can just check the current entry that comes up in the loop.
(edit:) In your isPrime you perform a binary search by hand, but there is already a binary_search algo in STL. And you won't need it at all, if you keep your vector<bool> sieve array as is, without compressing. Then isPrime(i) needs just to check whether the array's value at the index i is still true.
(edit2:) Now, about efficiency. You recalculate up to n+n, probably in anticipation of more numbers to test. If you only test few, simple trial division on odds will be faster. If the numbers to test are all in a narrow-ish upper region, your best option is offset sieve with the lower sieve done up to the sqrt of the test region's upper limit. And if the numbers are widely distributed, then your current whole array approach can be used.
The key facts to use here is that there are approximately n ~= m/log m primes below m in value, that to sieve an array from 0 to m takes O(m*log (log m)) time, and that to sieve the upper region between a and b, i.e. with width d=b-a, by all the primes below r=sqrt b, it'd take time proportional to d*log (log r).
Also, when growing your sieve array it is best to expand, and not to recalculate the whole anew. The primes are all there. To sieve the appendage it will be necessary to loop through all the primes in the sieve array up to the sqrt of its new upper edge. This is reminiscent of segmented sieve, although there each new segment comes instead of, or in any case separately from a previous one.