-- $Id: Aufgabe1.hs,v 1.1 2003/11/07 10:14:32 fp010 Exp $
module Aufgabe1 where

-- teil A, 1.)

sumSquareRec, sumSquareNRec :: Integer -> Integer

sumSquareRec 0 = 0
sumSquareRec n = (n * n) + (sumSquareRec (n - 1))

-- ist es eigentlich bei haskell sinnvoll tail-recursive
-- anzuschreiben? oder optimiert der interpreter das selbstaendig?

sumSquareNRec n = sum [ x * x | x <- [1..n]]

-- alternativ koennte man auch map, fold*, scan*, usw verwenden...
-- z.B.:


-- sumSquareNRec 0		=  0
-- sumSquareNRec n		=  foldl (+) 0 (map (^2) [0..n])

-- oder war hier wirklich komplett recursionsfrei vorgesehen? (also
-- mittels summationsformel? wie diese hier:

-- sumSquareNRec n = (div 1 (6*(2*n^3+3*n^2+n)))

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

-- teil A, 2.)

-- hier ist die angabe leider etwas ungenau...
-- annahme, einfach die combinationen...

anzTipps :: Integer -> Integer -> Integer
anzTipps y x | x >= y	=  div (fact x) ((fact y) * (fact (x-y)))
	     | y <  x	=  error "Kombinationen gehen so nicht."
    where fact n = product [1..n] 

-- man kann eigentlich fact n / fact m optimieren, indem man 
-- (product [(m-1)..n]) verwendet...

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

-- teil A, 3.)

-- bin faul... und ausserdem kenn ich die list-comprehension+zip
-- variante eh auswendig...

fib = (!!) allfib where
  allfib = 1 : 1 : [ x+y | (x,y) <- (zip allfib (tail allfib)) ]

-- die anfaenger variante waere
-- fib 0 = 1
-- fib 1 = 1
-- fib n = fib (n - 1) + (fib (n - 2))    -- atemberaubend nonperformant
-- gewesen... aber wieso einfach, wenn's auch funktionaler geht ;)

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

-- teil A, 4.)

-- na ok, machmas...

kVA :: Double -> (Double,Double)
kVA r = (v,a) where
  pi = 3.14
  a  = 4 * pi * r * r
  v  = a * r / 3