module Main where

import System
-- import qualified AtkinSieve      (primesUpTo)
import qualified GalePrimes2     (primesUpTo)
import qualified NaiveSieve      (primesUpTo)
import qualified NaiveSieveLimit (primesUpTo)
import qualified NaiveSieveWheel (primesUpTo)
import qualified ONeillPrimes    (primesUpTo)
import qualified ReinkePrimes    (primesUpTo)
import qualified RuncimanPrimes  (primesUpTo)
import qualified SimplePrimes    (primesUpTo)
import qualified ZilibowitzPrimes(primesUpTo)
import qualified NofibPrimes     (primesUpTo)
import qualified OlegPrimes      (primesUpTo)
import qualified LennartPrimes   (primesUpTo)


main = do
    args <- getArgs
    let n = read (head args)
        prime f = printNthPrime f n

    mapM_ prime -- [ AtkinSieve.primesUpTo
                [GalePrimes2.primesUpTo
                ,NaiveSieve.primesUpTo
                ,NaiveSieveLimit.primesUpTo
                ,NaiveSieveWheel.primesUpTo
                ,ONeillPrimes.primesUpTo
                ,ReinkePrimes.primesUpTo
                ,RuncimanPrimes.primesUpTo
                ,SimplePrimes.primesUpTo
                ,NofibPrimes.primesUpTo
                ,OlegPrimes.primesUpTo
                ,LennartPrimes.primesUpTo
                ,ZilibowitzPrimes.primesUpTo ]


------------------------------------------------------------------------

primesToLimit f n = f n

primesToNth f n = take n (primesToLimit f (nThPrimeApprox n))

printNthPrime f n = putStrLn . filter (/=' ') . show $ (n, last (primesToNth f n))

-- Often we want a finite list of primes, not an infinite one; so below
-- we have a revised version of the above code that produces finite lists.
-- The advantage of finite (but lazy) lists, even very long ones, is that
-- we don't have to keep track of every prime we encounter in the heap.

nThPrimeApprox :: Int -> Integer
nThPrimeApprox nth
    | n < 13    = 37
    | otherwise = round realApprox
    where
       n          = fromInteger (toInteger (nth))
       realApprox = n * (log n + log (log n) - 1 + 1.8 * log (log n) / log n)