fix indenting of aufgabe3

2 files changed, 28 insertions, 28 deletions

diff --git a/AufgabeFFP3.hs b/AufgabeFFP3.hs
index 459f510..8b1d748 100644
--- a/AufgabeFFP3.hs
+++ b/AufgabeFFP3.hs
@@ -16,36 +16,36 @@ type MaxWeight = Weight
 
 safeGet :: [Integer] -> Int -> Integer -- get element of list, default to 0
 safeGet l i
-        | i < length l = l !! i
-        | otherwise = 0
+  | i < length l = l !! i
+  | otherwise = 0
 
 toBin :: Integer -> [Integer] -- get binary representation of integer
 toBin 0 = []
 toBin i = [rem] ++ toBin quot
-        where ( quot, rem ) = quotRem i 2
+  where ( quot, rem ) = quotRem i 2
 
 hasBit :: Integer -> Int -> Bool -- check if the binary representation of a number has the ith bit set
 hasBit num ith = (safeGet (toBin num) ith) == 1
 
 getChoice :: Items -> Int -> Items -- choose a subset determined by binary representation of l
 getChoice l i = concat ( map (choose l) [0..(length l)-1]  )
-        where
-        choose l pos 
-                | hasBit (fromIntegral i) pos = [ l !! pos ]
-                | otherwise = []
+  where
+  choose l pos
+    | hasBit (fromIntegral i) pos = [ l !! pos ]
+    | otherwise = []
 
 generator:: Items -> Loads -- get all possible choices (2^n)
 generator l = map ( getChoice l ) [1..num]
-        where num = (2^(length l)) - 1
+  where num = (2^(length l)) - 1
 
 transformer :: Loads -> [LoadWghtVal] -- calc sum of weight and value for all lists of items
 transformer l = map trans l
 
 trans :: Load -> LoadWghtVal -- worker of transformer
 trans load = (load, weight, value)
-        where 
-        weight = sum $ map fst load
-        value = sum $ map snd load
+  where
+  weight = sum $ map fst load
+  value = sum $ map snd load
 
 getWeight :: LoadWghtVal -> Weight
 getWeight (_, w, _) = w
@@ -58,16 +58,16 @@ filter max l = [ x | x <- l, getWeight x <= max ]
 
 selector :: [LoadWghtVal] -> [LoadWghtVal] -- get those with max val
 selector l = [ x | x <- l, getVal x == max ]
-        where max = maximum $ map getVal l
+  where max = maximum $ map getVal l
 
 selector1 :: [LoadWghtVal] -> [LoadWghtVal] -- all with max val
 selector1 = selector
 
 selector2 :: [LoadWghtVal] -> [LoadWghtVal] -- get ones with min weight
 selector2 l = [ x | x <- best, getWeight x == min ]
-        where
-        min = minimum $ map getWeight best
-        best = selector l 
+  where
+  min = minimum $ map getWeight best
+  best = selector l
 
 
 -- pascal's triangle from exercise 1
@@ -77,22 +77,22 @@ pd = [[1]] ++ (zipWith (\x y -> zipWith (+) ([0] ++ x) (y ++ [0])) pd pd)
 -- naive
 binom :: (Integer, Integer) -> Integer
 binom (n, k)
-                | k == 0 || n == k = 1
-                | otherwise = binom (n-1, k-1) + binom (n-1, k)
+    | k == 0 || n == k = 1
+    | otherwise = binom (n-1, k-1) + binom (n-1, k)
 
 -- stream using pascal
 binomS :: (Integer, Integer) -> Integer
 binomS (n, k) = pd !! fromInteger n !! fromInteger k
 
--- calc table 
+-- calc table
 binomMemoTable :: [[Integer]]
 binomMemoTable = [ [ binomM (n, k)  | k <- [0..] ] | n <- [0..] ]
 
 -- using memoisation
 -- base case or recursion formula using lookup table
 binomM :: (Integer, Integer) -> Integer
-binomM (n, k) 
-        | k == 0 || n == k = 1
-        | otherwise = get (n-1) (k-1) + get (n-1) (k)
-        where get n k = binomMemoTable !! fromInteger n !! fromInteger k
+binomM (n, k)
+  | k == 0 || n == k = 1
+  | otherwise = get (n-1) (k-1) + get (n-1) (k)
+  where get n k = binomMemoTable !! fromInteger n !! fromInteger k
 
diff --git a/TestAufgabeFFP3.hs b/TestAufgabeFFP3.hs
index c83099c..065401d 100644
--- a/TestAufgabeFFP3.hs
+++ b/TestAufgabeFFP3.hs
@@ -12,26 +12,26 @@ cases1 = TestLabel "foo" $ TestList [
   TestCase $ assertEqual "b" ((selector1 . (filter 13) . transformer . generator) [(5,3),(2,7),(2,6),(10,100)]) [([(2,7),(10,100)],12,107)],
   TestCase $ assertEqual "c" ((selector1 . (filter 1) . transformer . generator) [(5,3),(2,7),(2,6),(10,100)]) [],
   TestCase $ assertEqual "d" ((selector1 . (filter 5) . transformer . generator) [(5,13),(2,7),(2,6),(10,100)]) [([(5,13)],5,13), ([(2,7),(2,6)],4,13)],
-        TestCase $ assertEqual "e" ((selector2 . (filter 5) . transformer . generator) [(5,13),(2,7),(2,6),(10,100)]) [([(2,7),(2,6)],4,13)]
-        ]
+  TestCase $ assertEqual "e" ((selector2 . (filter 5) . transformer . generator) [(5,13),(2,7),(2,6),(10,100)]) [([(2,7),(2,6)],4,13)]
+  ]
 
 cases2 = TestLabel "bar" $ TestList [
   TestCase $ assertEqual "a" [ binomS (8, i) | i <- [0..7] ] [ binom (8, i) | i <- [0..7] ],
   TestCase $ assertEqual "a" (binom (1,1)) (binomS (1,1)),
   TestCase $ assertEqual "a" (binom (2,1)) (binomS (2,1)),
   TestCase $ assertEqual "a" (binom (18,12)) (binomS (18,12))
-        ]
+  ]
 
 cases3 = TestLabel "bar" $ TestList [
   TestCase $ assertEqual "a" [ binomM (8, i) | i <- [0..7] ] [ binom (8, i) | i <- [0..7] ],
   TestCase $ assertEqual "a" (binom (1,1)) (binomM (1,1)),
   TestCase $ assertEqual "a" (binom (2,1)) (binomM (2,1)),
   TestCase $ assertEqual "a" (binom (18,12)) (binomM (18,12))
-        ]
+  ]
 
 cases4 = TestLabel "bar" $ TestList [
   TestCase $ assertEqual "a" ( [binomS (n, k) | k <- [0..50], n <- [k..50] ] ) ( [binomM (n, k) | k <- [0..50], n <- [k..50] ] ) 
-        ]
+  ]
 
 
 tests :: [Test]
@@ -39,5 +39,5 @@ tests = [cases1, cases2, cases3, cases4]
 
 main = do
   forM tests $ \test ->
-            runTestTT test
+    runTestTT test