module Simple where

-- einfache Funktionen

add :: Int -> Int -> Int
add    x      y   =  x + y

square :: Int -> Int
square    x   =  x * x

simple       :: Int -> Int -> Int -> Int
simple a b c =  a * (b+c)

rest, quotient :: Int -> Int -> Int
rest   x y   =  x `mod` y
quotient x y =  x `div` y 


-- Konstanten

newline :: Char
newline =  '\n'

eps :: Double
eps =  0.000001

-- Test auf identische Argumente

allEqual       :: Int -> Int -> Int -> Bool
allEqual n m p =  (n==m) && (m==p)


-- eigene Maximumsfunktion, max ist vordefiniert
maxi                 :: Int -> Int -> Int
maxi n m | n>=m      =  n
         | otherwise =  m



--------------------------------------------------------------
-- Beispiel: Zahlen eines Intervalls multiplizieren
--------------------------------------------------------------
-- Die Zahlen in einem gegebenen Intervall [low|high] sollen 
-- multipliziert werden: low * (low+1) * .... * high
--
-- !!! Implizite Annahme:  low <= high !!!
--

-- sequentielle Definition
prodSeq                   :: Integer -> Integer -> Integer
prodSeq low high 
        | low == high   =  low
        | otherwise     =  low * prodSeq (low+1) high


-- Divide et impera! (Divide and Conquer)
prodDC                  :: Integer -> Integer -> Integer
prodDC low high  
        | low == high   =  low 
        | low+1 == high =  low * high
        | otherwise     =  prodDC low ((low+high) `div` 2)  
                           * prodDC ((low+high) `div` 2 + 1) high


-- Vermeidung von Mehrfachauswertung 
prod                    :: Integer -> Integer -> Integer
prod low high  
        | low == high   =  low 
        | low+1 == high =  low * high
        | otherwise     =  prod low mid * prod (mid+1) high
        where  mid = (low+high) `div` 2 
                           
prodlet               :: Integer -> Integer -> Integer
prodlet low high  
        | low == high   =  low 
        | low+1 == high =  low * high
        | otherwise     =  let mid = (low+high) `div` 2 
                           in  prodlet low mid * prodlet (mid+1) high  
 



--------------------------------------------------------------
-- Beispiel: Verkaufszahlen analysieren
--------------------------------------------------------------


-- sales gibt zu einer Wochennummer die Verkaufszahl
sales :: Int -> Int
sales    n   =  (n `mod` 3) + (n `mod` 5) 


-- totalSales bestimmt zu einer Wochennummer 
-- die Summe der Verkaufszahlen bis zu dieser Woche
totalSales     :: Int -> Int
totalSales n 
      |  n==0  =  sales 0
      |  n>0   =  totalSales (n-1) + sales n
      |  n<0   =  error "ungueltige Wochennummer"
-- error :: String -> a

-- maxSales bestimmt die Wochennummer mit der hoechsten 
-- Verkaufszahl bis zur eingegebenen Wochennummer
maxSales0           :: Int -> Int
maxSales0 n   
      | n==0        =  0
      | (n>0) && sales (maxSales0 (n-1)) > sales n  
                    =  maxSales0 (n-1)
      | otherwise   =  n

-- maxSales0 wertet maxSales0 (n-1) mehrfach aus
-- Hier ist eine effizientere Version, die die
-- Mehrfachauswertung vermeidet:

maxSales            :: Int -> Int
maxSales n   
      | n==0        =  0
      | (n>0) && sales (maxAlt) > sales n  
                    =  maxAlt
      | otherwise   =  n
      where maxAlt = maxSales (n-1)



-- 
-- alternative endrekursive Berechnung von searchMax
--
maxSales2 :: Int -> Int
maxSales2    n   =  searchMax n 0 0

searchMax  n i m
   | n<0   = n
   | i>n   = m
   | i<=n && sales m > sales i   
           = searchMax n (i+1) m
   | otherwise 
           = searchMax n (i+1) i