Didn’t post correctly

from math import *

def sieve2(n):
index = 0
numberList = range(3,n+1,2)
while numberList[index] = sqrt(n):
break
return [2] + numberList

Here is my code:

#include
#include
#include
#include
#include
using namespace std;

const unsigned long MAX_NUMBER = 15485863;
vector numbers(MAX_NUMBER+1);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
unsigned long l1,l2;

// thread specific arguments
struct thread_data
{
unsigned int thread_id;
unsigned long n; // data to sieve
bool bw; // backward or forward search
};

struct thread_data thread_data_array[2];

void init_numbers(vector * numbers);

void *prime_sieve(void *arg);

void init_numbers(vector * numbers)
{
unsigned long i;
(*numbers)[2]=true;
for (i=3;ibw))
{
while (l1 <= l2)
{
if (numbers[l1] != false)
{
c = l1*l1;
pos_move = (l1 << 1);
while (c n)
{
pthread_mutex_lock(&mutex1);
numbers[c]=false;
pthread_mutex_unlock(&mutex1);
c += pos_move;
}
}
pthread_mutex_lock(&mutex1);
l1++;
pthread_mutex_unlock(&mutex1);
}
}
else
{
while(l2 >= l1)
{
if (numbers[l2] != false)
{
c = l2*l2;
pos_move = (l2 << 1);
while (c n)
{
pthread_mutex_lock(&mutex1);
numbers[c]=false;
pthread_mutex_unlock(&mutex1);
c += pos_move;
}
}
pthread_mutex_lock(&mutex1);
l2–;
pthread_mutex_unlock(&mutex1);
}
}
pthread_exit(NULL);
}

unsigned long get_primes(vector numbers, unsigned long n)
{
unsigned long primes=0;
for(unsigned int i=0;i<=n;i++)
{
primes+=numbers[i];
}
return primes;
}

int main(int argc, char *argv[])
{
pthread_t threads[2];
int rc;
unsigned long n = MAX_NUMBER;
init_numbers(&numbers);

l1 = 2;
l2 = (int)(sqrt(n))+1;

thread_data_array[0].thread_id = 0;
thread_data_array[0].n = MAX_NUMBER;
thread_data_array[0].bw = false;
rc = pthread_create(&threads[0], NULL, prime_sieve, (void *) &thread_data_array[0]);

thread_data_array[1].thread_id = 1;
thread_data_array[1].n = MAX_NUMBER;
thread_data_array[1].bw = true;
rc = pthread_create(&threads[1], NULL, prime_sieve, (void *) &thread_data_array[1]);

void* retval;
pthread_join(threads[0], &retval);
pthread_join(threads[1], &retval);

cout << get_primes(numbers, n) << endl;
}

if __name__ == "__main__":
print len(primes_sieve(15485863))


function primes=sieve(maxnum)
%Sieve of Erasthenes for finding primes less than or equal to the input
%argument
mask=ones(ceil((maxnum-1)/2),1);
for i=3:2:floor(sqrt(maxnum))
   if mask((i-1)/2)
        mask((i^2-1)/2:i:end)=0;
   end
end
primes=[2;2*find(mask)+1];

It’s a tiny bit faster than the nearly-identical Matlab implementation, called primes.

let sieve_of_eratosthenes (proc : int -> unit) n =
  let limit = (n - 3) asr 1 in
  let sieve = BitSet.create_full (limit + 1) in
  let i = ref 0
  and p = ref 3
  and q = ref 9 in
  while !q < n do
    if BitSet.is_set sieve !i then begin
      let j = ref ((!q - 3) asr 1) in
      while !j <= limit do
        BitSet.unset sieve !j;
        j := !j + !p
      done
    end;
    incr i;
    p := !p + 2;
    q := !q + (!i + 1) lsl 3
  done;
  proc 2;
  foreach (BitSet.enum sieve) (fun i -> if i <= limit then proc (i lsl 1 + 3))

; we work only with odd numbers till N
(defn odds [n] (vec (range 3 (inc n) 2)))

; it's easy to calculate index of a value in our vector of odds
(defn odds-idx [v] (/ (- v 3) 2))

; just sieve the vector from start=(index of v²)
(defn sieve [max-idx nums v]
  (let [start (odds-idx (* v v))]
    (reduce #(assoc %1 %2 nil) nums (range start max-idx v))))

; get primes equal or less than N
(defn primes [n]
  (let [max-i (Math/floor (odds-idx n))]
    (loop [nums (odds n) i 0]
      (if-let [v (nums i)]
        (if (> (* v v) n)
          (cons 2 (remove nil? nums))
          (recur (sieve max-i nums v) (inc i)))
        (recur nums (inc i))))))

(count (primes 15485863))
1000000