module AufgabeFFP2
where

-- 1

primes :: [Integer]
primes = sieve [2 ..]

-- sieve of eratosthenes (according to lecture slides)
sieve :: [Integer] -> [Integer]
sieve (x:xs) = x : sieve [ y | y <- xs, mod y x > 0]

-- generate all pairs with map and then filter only the valid ones
-- TODO: filtering should be optimized, still a bit slow
pps :: [(Integer, Integer)]
pps = filter validPair $ map (\x -> (x,x+2)) primes
	where
		-- pair is valid if the second component n is a prime
		-- since simply checking if the Integer is element of the prime-list 
		-- does not terminate for non-primes, we take the first n primes
		validPair :: (Integer,Integer) -> Bool
		validPair (_,maybePrime) = elem maybePrime $ take (fromInteger maybePrime) primes
				
-------------------------------------------------------------------------------

-- 2

-- generates powers of 2	
pof2s :: [Integer]
pof2s = [1] ++ (map (2*) pof2s)
	
pow :: Int -> Integer
pow 0 = 1
pow n = pow (n-1) + pow (n-1)

-- uses memtable for power-calculation
powFast :: Int -> Integer
powFast 0 = 1
powFast n = pof2s !! (n-1) + pof2s !! (n-1)

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

-- 3

-- power series of N
pofNs :: Integer -> [Integer]
pofNs n = [1] ++ (map (n*) $ pofNs n)

-- faculty function
fac :: Integer -> Integer
fac n = product [1..n]

-- stream of faculties
facGen :: [Integer]
facGen = map (fac) [1..]

-- function g with memoization (using hFast)
fMT :: Int -> Int -> Float
fMT z k = g z k hMT

-- function g without memoization (uning hSlow)
f :: Int -> Int -> Float
f z k = g z k h

-- actual function g (converts Int to Integer for more precision)
g :: Int -> Int -> (Integer -> Integer -> Float) -> Float
g z k h = sum $ map (h $ fromIntegral z) [1..(fromIntegral k)]
	
-- helper function h using mem-table for the power-series (z^i) and for faculty (i!)
hMT :: Integer -> Integer -> Float
hMT z i = (fromInteger $ pofNs z !! (fromInteger i)) / (fromInteger $ facGen !! ((fromIntegral i)-1))

-- helper function h without memoization
h :: Integer -> Integer -> Float
h z i =  (fromInteger $ z^i) / (fromInteger $ fac i)

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

-- 4

-- gets the digits of an integer as a list
digits :: Integer -> [Integer]
digits x
	| x<=0 = []
	| otherwise = (digits $ x `div` 10)++[x `mod` 10]

-- calculates the goedel-number for the given integer
-- returns 0 for non-positive numbers
gz :: Integer -> Integer
gz n
	| n<=0 = 0
	| otherwise = product $ zipWith (^) primes (digits n)

-- goedel-number generator
gzs :: [Integer]
gzs = map (gz) [1..]