Functies definiëren nDoor combinatie van standaardfuncties fac :: Int  Int fac n = product [1..n] oneven :: Int  Bool oneven n = not (even n) negatief.

Presentatie over: "Functies definiëren nDoor combinatie van standaardfuncties fac :: Int  Int fac n = product [1..n] oneven :: Int  Bool oneven n = not (even n) negatief."— Transcript van de presentatie:

1 Functies definiëren nDoor combinatie van standaardfuncties fac :: Int  Int fac n = product [1..n] oneven :: Int  Bool oneven n = not (even n) negatief :: Int  Bool negatief n = n < 0

2 Functies uitrekenen nMet de interpretern Met de compiler module Stat where fac n = product [1..n] module Stat where fac n = product [1..n] main = fac 6 H:\> hi > :l Stat > fac 6 720 H:\> helium Stat.hs H:\> lvmrun Stat 720

3 Gevallen onderscheiden abs :: Int  Int abs x = x = -x | x>=0 | x<0 “guards”

4 Herhalen fac :: Int  Int fac n = 1 = | n==0 | n>0 “recursie” n * fac (n-1) graag zonder product te gebruiken

5 Lijst-patronen null :: [Int]  Bool null [ ] = True null (x:xs) = False head :: [Int]  Int head (x:xs) = x tail :: [Int]  [Int] head (x:xs) = xs

6 Zelftest nDefinieer de recursieve functie umet patronen umet gevalsonderscheid d.m.v. guards sum sum :: [Int]  Int sum [ ] = 0 sum (x:xs)= x + sum xs sum :: [Int]  Int sum xs| null xs= 0 | True= head xs + sum (tail xs)

7 Quiz (basisschool) 5 + 3 + 2 5 + 3 * 2 3 * 2 16 10 5 - 3 - 2 04 5 ^ 3 ^ 2 125 2 5959 5 - 3 3 ^ 2 machtsverheffen 11 10 prioriteitsregel associatief links-associatief rechts-associatief

8 Quiz (logica) F  T  F F F  T  F TT F  T  F T  F implicatie F associatief rechts-associatief TF

9 Quiz (Helium) x : y : z x ++ y ++ z y : zs los element op kop van lijst rechts-associatief associatief lijsten samenvoegen

10 Quiz (Helium) f y z boven n k links-associatief map fac [1,2,3] map fac boven n toepassen van een functie

11 Partieel parametriseren nStel: nEn dan: plus :: Int  Int  Int plus x y = x + y drieMeer :: Int  Int drieMeer = plus 3 > map drieMeer [1, 2, 3, 4, 5] [4, 5, 6, 7, 8]

12 Partieel parametriseren nOmgekeerd: nEn dus: plus :: Int  (Int  Int) drieMeer = plus 3 drieMeer :: Int  Int plus :: Int  Int  Int rechts-associatief

13 “Curry-ing” nType nAanroep f :: Int  Bool  String > f 7 True “hoi” f 7 Bool  String  rechts-associatief links-associatief zonder haakjes!

14 Currying nHaskell B. Curry (1900-1982) nGrundlagen der kombinatorischen Logik (1930) nM. Schönfinkel Über die Bausteine der mathematischen Logik (1924) Schönfinkelin g?

15 Currying en map > map fac [1, 2, 3, 4, 5] [1, 2, 6, 24, 120] > map (plus 3) [1, 2, 3, 4, 5] [4, 5, 6, 7, 8] > map ((*) 2) [1, 2, 3, 4, 5] [2, 4, 6, 8, 10]

16 Hogere-ordefuncties nFunctie met een functie als parameter nFunctie met een functie als resultaat map inverse afgeleide elke functie met >1 parameter! filter

17 Hogere-ordefuncties nEen lijst langs lopen en met elk element iets doen nEen lijst langs lopen en sommige elementen selecteren map filter

18 map en filter > map even [1, 2, 3, 4, 5, 6] [False, True, False, True, False, True] > filter even [1, 2, 3, 4, 5, 6] [2, 4, 6] doe dit overal pak alleen deze

19 Publieksvraag nSchrijf een functie die getallen van een lijst oplevert die kleiner zijn dan 10 kleintjes kleintjes :: [Int]  [Int] kleintjes xs = filter ((>)10) xs (>) 10 x 10>x x<10 ook partieel geparametriseerd!

20 Definitie van map nGeef een recursieve definitie: map :: (a  b)  [a]  [b] map f [ ]= map f (x:xs)= [ ] map f xsf x :

21 Definitie van filter nGeef een recursieve definitie, en gebruik guards voor gevalsonderscheid filter :: (a  Bool)  [a]  [a] filter p [ ] = filter p (x:xs) = [ ] x : filter p xs | p x | True = filter p xs

22 Een ander soort lijst-functies product :: [Int]  Int product [ ]= product (x:xs)= 1 product xs x * and :: [Bool]  Bool and [ ]= and (x:xs)= True and xs x && sum :: [Int]  Int sum [ ]= sum (x:xs)= 0 sum xs x +

23 Universele “lijst-totalisator” foldr :: [a]  a foldr (#) e [ ] = foldr (#) e (x:xs)= e foldr (#) e xs x # (a  a  a)  a  zo combineren neutrale waarde

24 Had dat eerder gezegd... nAls foldr de generalisatie is van sum, product, en and.... n.... dan zijn sum, product, en and speciale gevallen van foldr product= foldr (*) 1 and= foldr (&&) True sum= foldr (+) 0 or= foldr (||) False

25 Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  a  a)  a  [a]  a [a] doe dit pak deze combineer zo

26 Andere hogere-ordefuncties until :: (a  Bool)  (a  a)  a  a begin hiermee doe dit totdat dit geldt > until ((<)1000) ((*)2) 1 1024 filter p f x = | p x | True = x (f x) until p f

27 Andere hogere-ordefuncties (.) ::    begin hiermee doe dit en dan dat > map (not. even) [1, 2, 3, 4, 5, 6] [1, 3, 5] (.) g f x = g (f x) a (a  b) (b  c) c (a  c)

28 Partieel parametriseren > map (plus 5) [1.. 5] [6, 7, 8, 9, 10] > until ((<)1000) ((*)2) 1 1024 > filter (not. even) [1.. 5] [1, 3, 5]

29 Partieel parametriseren > map f [1.. 4] where f x = x*x + 3*x + 2 [6, 12, 20, 30] > map f [1.. 4] [6, 12, 20, 30] ( \ x  x*x+3*x+2 )

30 Lambda-expressies x*x + 3*x + 2 expressie waar x vrij in voorkomt \ x  de functie die die expressie uitrekent

31 Lambda ? x. x*x + 3*x + 2    x. x*x + 3*x + 2 x. x*x + 3*x + 2 (LAMBDA x)( x*x + 3*x + 2 ) \ x  x*x + 3*x + 2 \ x -> x*x + 3*x + 2

32 Toepassing: priemgetallen deelbaar :: Int  Int  Bool deelbaar t n = (t/n)*n == t delers :: Int  [Int] delers x = filter (deelbaar x) [2..x-1] priem :: Int  Bool priem x = null (delers x) priem = null. delers priemgetallen :: [Int] priemgetallen = filter priem [2..1000]

33 Toepassing: dag van de week > dag 31 12 2002 “dinsdag” dag d m j = weekdag (nummer d m j) weekdag 0 = “zondag” weekdag 1 = “maandag” weekdag 2 = “dinsdag” etc.

34 Toepassing: dag van de week nummer d m j = ( ( j-1) * 365 + ( j-1) / 4 - ( j-1) / 100 + ( j-1) / 400 + sum (take (m-1) (ms j)) + d ) `rem` 7 elk jaar 1 dag later, want 365 = 52*7+1

35 Toepassing: dag van de week ms j = [ 31, feb, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ] where feb | schrik j = 29 | True = 28 schrik j | deelb j 100 = deelb j 400 | True = deelb j 4

36 Toepassing: differentiëren diff :: (Float  Float)  (Float  Float) diff :: (Float  Float)  Float  Float diff f x = ( f (x+h) – f (x) ) / h where h = 0.000001

37 Toepassing: nulpunt nulpunt :: (Float  Float)  Float nulpunt f = until ok verbeter 1.0 where ok x =... verbeter x =...

38 Methode van Newton b f b b-d d = f(b) / f’(b) verbeter b = b – f b / diff f b ok b = abs (f b) < 0.0001

39 Toepassing: inverse wortel a = nulpunt (\x  x*x – a) arcsin a= nulpunt (\x  sin x – a) log a= nulpunt (\x  exp x – a) inverse :: (Float  Float)  (Float  Float) inverse f a = nulpunt (\x  f x – a)

40 Hoger-ordefuncties op lijsten nDoorloop een lijst en... map :: (a  b)  [a]  [b] filter :: (a  Bool)  [a]  [a] foldr :: (a  a  a)  a  [a]  a [a] doe dit pak deze combineer zo

41 Currying nType nAanroep f :: Int  Bool  String > f 7 True “hoi” f 7 Bool  String  rechts-associatief links-associatief zonder haakjes!