sieve_of_eratosthenes.cpp File Reference

Prime Numbers using Sieve of Eratosthenes More...

#include <cstdint>
#include <cassert>
#include <iostream>
#include <vector>

Include dependency graph for sieve_of_eratosthenes.cpp:

Go to the source code of this file.

Namespaces
namespace	math
	for assert
namespace	sieve_of_eratosthenes
	Functions for finding Prime Numbers using Sieve of Eratosthenes.

Functions
std::vector< bool >	math::sieve_of_eratosthenes::sieve (uint32_t N)
	Function to sieve out the primes.
void	math::sieve_of_eratosthenes::print (uint32_t N, const std::vector< bool > &is_prime)
	Function to print the prime numbers.
static void	tests ()
	Self-test implementations.
int	main ()
	Main function.

Detailed Description

Prime Numbers using Sieve of Eratosthenes

Sieve of Eratosthenes is an algorithm that finds all the primes between 2 and N.

Time Complexity : \(O(N \cdot\log \log N)\)
Space Complexity : \(O(N)\)

See also

primes_up_to_billion.cpp prime_numbers.cpp

Definition in file sieve_of_eratosthenes.cpp.

Function Documentation

main()

int main

(

void

)

Main function.

Returns

0 on exit

Definition at line 119 of file sieve_of_eratosthenes.cpp.

           {
    tests();
    return 0;
}

print()

void math::sieve_of_eratosthenes::print	(	uint32_t	N,
		const std::vector< bool > &	is_prime )

Function to print the prime numbers.

Parameters

N	number till which primes are to be found
is_prime	a vector of N + 1 booleans identifying if i^th number is a prime or not

Definition at line 65 of file sieve_of_eratosthenes.cpp.

                                                        {
    for (uint32_t i = 2; i <= N; i++) {
        if (is_prime[i]) {
            std::cout << i << ' ';
        }
    }
    std::cout << std::endl;
}

sieve()

std::vector< bool > math::sieve_of_eratosthenes::sieve

(

uint32_t

N

)

Function to sieve out the primes.

This function finds all the primes between 2 and N using the Sieve of Eratosthenes algorithm. It starts by assuming all numbers (except zero and one) are prime and then iteratively marks the multiples of each prime as non-prime.

Contains a common optimization to start eliminating multiples of a prime p starting from p * p since all of the lower multiples have been already eliminated.

Parameters

N	number till which primes are to be found

Returns

is_prime a vector of N + 1 booleans identifying if i^th number is a prime or not

Definition at line 45 of file sieve_of_eratosthenes.cpp.

                                  {
    std::vector<bool> is_prime(N + 1, true);  // Initialize all as prime numbers
    is_prime[0] = is_prime[1] = false;        // 0 and 1 are not prime numbers
 
    for (uint32_t i = 2; i * i <= N; i++) {
        if (is_prime[i]) {
            for (uint32_t j = i * i; j <= N; j += i) {
                is_prime[j] = false;
            }
        }
    }
    return is_prime;
}

tests()

void tests ( )

static

Self-test implementations.

Returns

void

Definition at line 81 of file sieve_of_eratosthenes.cpp.

                    {
    std::vector<bool> is_prime_1 =
        math::sieve_of_eratosthenes::sieve(static_cast<uint32_t>(10));
    std::vector<bool> is_prime_2 =
        math::sieve_of_eratosthenes::sieve(static_cast<uint32_t>(20));
    std::vector<bool> is_prime_3 =
        math::sieve_of_eratosthenes::sieve(static_cast<uint32_t>(100));
 
    std::vector<bool> expected_1{false, false, true,  true,  false, true,
                                 false, true,  false, false, false};
    assert(is_prime_1 == expected_1);
 
    std::vector<bool> expected_2{false, false, true,  true,  false, true,
                                 false, true,  false, false, false, true,
                                 false, true,  false, false, false, true,
                                 false, true,  false};
    assert(is_prime_2 == expected_2);
 
    std::vector<bool> expected_3{
        false, false, true,  true,  false, true,  false, true,  false, false,
        false, true,  false, true,  false, false, false, true,  false, true,
        false, false, false, true,  false, false, false, false, false, true,
        false, true,  false, false, false, false, false, true,  false, false,
        false, true,  false, true,  false, false, false, true,  false, false,
        false, false, false, true,  false, false, false, false, false, true,
        false, true,  false, false, false, false, false, true,  false, false,
        false, true,  false, true,  false, false, false, false, false, true,
        false, false, false, true,  false, false, false, false, false, true,
        false, false, false, false, false, false, false, true,  false, false,
        false};
    assert(is_prime_3 == expected_3);
 
}