Problem Statement

The sieve of Eratosthenes: you've been there; done that; have the T-shirt. The sieve of Eratosthenes was ancient history when Euclid was a schoolboy. You are ready for something less than 3000 years old. You are ready for The sieve of Sundaram. Starting with the ordered set of +ve integers, mark every third starting at 4 (4;7;10...). Step through the set and if the value is not marked output 2*n+1. So from 1 to 4 output 3 5 7. 4 is marked so skip for 5 and 6 output 11 and 13. 7 is marked, so no output but now also mark every fifth starting at 12 (12;17;22...) as per to 10 and now mark every seventh starting at 17 (17;24;31....) as per for every further third element (13;16;19...) mark every (9th;11th;13th;...) element. The output will be the ordered set of odd primes. Using your function find and output the first 100 and the millionth Sundaram prime. The faithless amongst you may compare the results with those generated by The sieve of Eratosthenes. Comment on the Sundaram Sieve In case casual readers and programmers read the above blurb and get the impression that something several thousand years newer must needs be better than the "old" Sieve of Eratosthenes (SoE), do note the only difference between the Sieve of Sundaram (SoS) and the odds-only SoE is that the SoS marks as composite/"culls" according to all odd "base" numbers as is quite clear in the above description of how to implement it and the above linked Wikipedia article (updated), and the SoE marks as composite/"culls" according to only the previously determined unmarked primes (which are all odd except for two, which is not used for the "odds-only" algorithm); the time complexity (which relates to the execution time) is therefore O(n log n) for the SoS and O(n log log n) for the SoE, which difference can make a huge difference to the time it takes to sieve as the ranges get larger. It takes about a billion "culls" to sieve odds-only to a billion for the SoE, whereas it takes about 2.28 billion "culls" to cull to the same range for the SoS, which implies that the SoS must be about this ratio slower for this range with the memory usage identical. Why would one choose the SoS over the SoE to save a single line of code at the cost of this much extra time? The Wren comparison at the bottom of this page makes that clear, as would implementing the same in any language.

Let's start with the solution:

# `sieve_of_Sundaram` as defined here generates the stream of
# consecutive primes from 3 on but less than or equal to the specified
# limit specified by `.`.
# input: an integer, n
# output: stream of consecutive primes from 3 but less than or equal to n
def sieve_of_Sundaram:
    def idiv($b): (. - (. % $b))/$b ;
    debug |
    round as $n
    | if $n < 2 then empty
      else 
        ((($n-3) | idiv(2)) + 1) as $k
        | [range(0; $k + 1) | 1 ] # integers_list 
        | reduce range (0; (($n|sqrt) - 3) / 2 + 1) as $i (.;
            (2*$i + 3) as $p
            | ((($p*$p - 3) | idiv(2))) as $s
            | reduce range($s; $k; $p) as $j (.;
	        if .[$j] then .[$j] = false else . end ) )
        | range(0; $k) as $i
        | if .[$i] then ($i+1)*2+1 else empty end
      end ;

# Emit an array of $n Sundaram primes.
# The first Sundaram prime is 3 so we ensure Sundaram_prime(1) is [3].
# An adaptive definition to ensure generality without being excessively conservative.
def Sundaram_primes($n):
  def sieve:
     . as $in
     | [limit($n; sieve_of_Sundaram)]
     | if length == $n then .
       else ($n + $in) as $m
       | ("... nth_Sundaram_prime(\($n)): \($in) => \($m))" | debug) as $debug
       | $m | sieve
       end;
  if $n < 1 then empty
  elif $n <= 100 then ($n | 1.2 * . * log) | sieve
  else $n | (1.15 * . * log) | sieve # OK
  end;

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

def nwise($n):
  def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
  n;

def hundred:
  Sundaram_primes(100)
  | nwise(10)
  | map(lpad(3))
  | join(" ");

"First hundred:", hundred,
"\nMillionth is \(Sundaram_primes(1000000)[-1])"