@2.3 Efficient factorial-generator

1 files changed, 12 insertions, 10 deletions

diff --git a/AufgabeFFP2.hs b/AufgabeFFP2.hs
index 44b2efb..0415b32 100644
--- a/AufgabeFFP2.hs
+++ b/AufgabeFFP2.hs
@@ -19,10 +19,11 @@ isPrime n = n > 1 &&
 primes :: [Integer]
 primes = 2:filter isPrime [3,5..]
 
+-- pairs of (p,p+2) | p,p+2 <- primes 
 -- generate all pairs with map and then filter only the valid ones
 -- pair is valid if the second component n is a prime
 pps :: [(Integer, Integer)]
-pps = filter (\(_,y) -> isPrime y) $ map (\x -> (x,x+2)) primes
+pps = filter (\(_,x) -> isPrime x) $ map (\p -> (p,p+2)) primes
                                 
 -------------------------------------------------------------------------------
 
@@ -32,11 +33,12 @@ pps = filter (\(_,y) -> isPrime y) $ map (\x -> (x,x+2)) primes
 pof2s :: [Integer]
 pof2s = [1] ++ map (2*) pof2s
         
+-- calculates 2^n
 pow :: Int -> Integer
 pow 0 = 1
 pow n = pow (n-1) + pow (n-1)
 
--- uses memtable for power-calculation
+-- same as pow but uses memtable for power-calculation
 powFast :: Int -> Integer
 powFast 0 = 1
 powFast n = pof2s !! (n-1) + pof2s !! (n-1)
@@ -49,14 +51,14 @@ powFast n = pof2s !! (n-1) + pof2s !! (n-1)
 pofNs :: Integer -> [Integer]
 pofNs n = [1] ++ (map (n*) $ pofNs n)
 
--- faculty function
+-- stream of factorials
+facs :: [Integer]
+facs = scanl (*) 1 [1..]
+
+-- factorial 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
@@ -69,9 +71,9 @@ f z k = g z k h
 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!)
+-- helper function h using mem-table for the power-series (z^i) and for factorial (i!)
 hMT :: Integer -> Integer -> Float
-hMT z i = (fromInteger $ pofNs z !! (fromInteger i)) / (fromInteger $ facGen !! ((fromIntegral i)-1))
+hMT z i = (fromInteger $ pofNs z !! (fromInteger i)) / (fromInteger $ facs !! (fromInteger i-1))
 
 -- helper function h without memoization
 h :: Integer -> Integer -> Float
@@ -96,4 +98,4 @@ gz n
 
 -- goedel-number generator
 gzs :: [Integer]
-gzs = map (gz) [1..]
+gzs = map gz [1..]