blob: 0415b32a671151187a60057642367878223117e6 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
module AufgabeFFP2
where
-- 1
-- primality check
isPrime :: Integer -> Bool
isPrime n = n > 1 &&
foldr (\p r ->
p*p > n
|| (
(n `mod` p) /= 0
&& r
)
)
True primes
-- series of primes
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 (\(_,x) -> isPrime x) $ map (\p -> (p,p+2)) primes
-------------------------------------------------------------------------------
-- 2
-- generates powers of 2
pof2s :: [Integer]
pof2s = [1] ++ map (2*) pof2s
-- calculates 2^n
pow :: Int -> Integer
pow 0 = 1
pow n = pow (n-1) + pow (n-1)
-- same as pow but 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)
-- stream of factorials
facs :: [Integer]
facs = scanl (*) 1 [1..]
-- factorial function
fac :: Integer -> Integer
fac n = product [1..n]
-- 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 factorial (i!)
hMT :: Integer -> Integer -> Float
hMT z i = (fromInteger $ pofNs z !! (fromInteger i)) / (fromInteger $ facs !! (fromInteger 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..]
|
