-- where sieving is done, thus sieving primes up to @n@ requires

-- @/O/(sqrt n/log n)@ space.

module Math.NumberTheory.Primes.Sieve

import Math.NumberTheory.Primes.Sieve.Eratosthenes

+-- There are three factors limiting the range of these sieves.

+-- (3) The internal representation of the state

+-- An Eratosthenes type sieve needs to store the primes up to the square root of

+-- the currently sieved region, thus requires @/O/(n\/log n)@ space.We store @16@ bytes

+-- of information per prime, thus a Gigabyte of memory takes you to about @1.6*10^18@.

+-- The @log@ doesn't change much in that range, so as a first approximation, doubling

+-- the storage increases the sieve range by a factor of four.

+-- On a 64-bit system, this is (currently) the only limitation to be concerned with, but

+-- with more than four Terabyte of memory, the fact that the internal representation

+-- currently limits the sieve range to about @6.8*10^25@ could become relevant.

+-- Overflow in array indexing doesn't become a concern before memory and internal

+-- representation would allow to sieve past @10^37@.

+-- On a 32-bit system, the internal representation imposes no additional limits,

+-- but overflow has to be reckoned with. On the one hand, the fact that arrays are

+-- 'Int'-indexed restricts the size of the prime store, on the other hand, overflow

+-- in calculating the indices to cross off multiples is possible before running out

+-- of memory. The former limits the upper bound of the monolithic 'primeSieve' to

+-- shortly above @8*10^9@, the latter limits the range of the segmented sieves to