Polymorf zoeken zoek :: (a  a  Bool)  [ (a, b) ]  a  b zoek eq [ ] x = ??? zoek eq ((a,b):ts) x | eq a x = b | otherwise = zoek eq ts x MayBe b No.

Presentatie over: "Polymorf zoeken zoek :: (a  a  Bool)  [ (a, b) ]  a  b zoek eq [ ] x = ??? zoek eq ((a,b):ts) x | eq a x = b | otherwise = zoek eq ts x MayBe b No."— Transcript van de presentatie:

1 Polymorf zoeken zoek :: (a  a  Bool)  [ (a, b) ]  a  b zoek eq [ ] x = ??? zoek eq ((a,b):ts) x | eq a x = b | otherwise = zoek eq ts x MayBe b No Yes b

2 Zelftest nSchrijf de functie (definitie en type) die overeenkomstige elementen van twee lijsten koppelt > zipWith (+) [1, 2, 3] [4, 5, 6, 7] [5, 7, 9] met een nader te specificeren operator zipWith

3 Lijst-comprehensies nNotatie uit de verzamelingenleer { x*x | x  N, x<10 } > [ x*x | x  [1..10], even x ] [4, 16, 36, 64, 100] > [ (x,y) | x  [1,4,8], y  ”ab” ] [ (1,’a’), (1,’b’), (4,’a’), (4,’b’), (8,’a’), (8,’b’) ]

4 Zelf datastructuren ontwerpen data Boom a = Blad | Tak a (Boom a) (Boom a) constructor functies het nieuwe type types van de parameters van de constructorfuncties Blad:: Boom a Tak:: a  Boom a  Boom a  Boom a

5 Functies op datastructuren nLijst nBoom length :: [a]  Int length [ ] = 0 length (x:xs) = 1 + length xs omvang :: Boom a  Int omvang Blad = 0 omvang Tak x li re = 1 + omvang li + omvang re constructor functies

6 Insert in een zoekboom insert :: (a  a  Ord)  a  Boom a  Boom a insert cmp e Blad= insert cmp e (Tak x li re)= Tak e Blad Blad cmp e xf ( ) wheref LT = f _ = Tak x (insert cmp e li) re Tak x li (insert cmp e re)

7 Toepassing: Breuken type Breuk = (Int, Int) 3434 maal:: Breuk  Breuk  Breuk plus:: Breuk  Breuk  Breuk eq:: Breuk  Breuk  Bool eenvoud :: Breuk  Breuk 3434 6565 1212 2424

8 Breuken vermenigvuldigen nTeller en noemer vermenigvuldigen 3434 6565 * 18 20 = maal:: Breuk  Breuk  Breuk maal (x,y) (p,q) = (x*p, y*q)

9 Breuken optellen nEerst gelijknamig maken 1414 3 10 + 22 40 = plus:: Breuk  Breuk  Breuk plus (x,y) (p,q) = (x*q+y*p, y*q) 10 40 12 40 +=

10 Breuken vergelijken nKruiselings vermenigvuldigen 2828 3 12 == True eq:: Breuk  Breuk  Bool maal (x,y) (p,q) = x*q == y*p

11 Toepassing: Polynomen type Term= (Float, Int) type Poly= [Term] 3.5x 4 + 6.1x 2 + 2.5 maal:: Poly  Poly  Poly plus:: Poly  Poly  Poly eq:: Poly  Poly  Bool eenvoud :: Poly  Poly

12 Polynomen optellen nSamenvoegen en vereenvoudigen + = plus:: Poly  Poly  Poly plus p q = eenvoud (p ++ q) 3x 4 + 4x 2 2x 2 + 13x 4 + 4x 2 + 2x 2 + 1 3x 4 + 6x 2 + 1

13 Polynomen vereenvoudigen nSorteren op exponent termen met gelijke exponent samenvoegen = eenvoud:: Poly  Poly eenvoud = 3x 4 + 4x 2 +2x 3 + x 2 + 13x 4 + 5x 2 + 2x 3 + 1 sorteren samenvoegen.verw0.

14 Polynomen vereenvoudigen eenvoud :: Poly  Poly eenvoud = verw0. samen. sorteren sorteren = isort ord whereord :: Term  Term  Ordering ord (c1,e1) (c2,e2) = ordInt e1 e2 samen ((c1,e1):(c2,e2):ts) | e1==e2 = samen ((c1+c2,e1):ts) | True = (c1,e1) : samen ((c2,e2):ts) samenv ts = ts verw0 = filter ( \(c,e)  c/=.0.0 )

15 Polynomen vermenigvuldigen nAlle termen met elkaar vermenigvuldigen * = maal:: Poly  Poly  Poly maal p q = eenvoud (cross tMaal p q) 3x + 12x 2 + 56x 3 +15x + 2x 2 +5 tMaal :: Term  Term  Term tMaal (c1,e1) (c2,e2) = (c1*.c2, e1+e2)

16 Kruisproduct nMet lijstcomprehensie nMet expliciete recursie cross :: (a  a  b)  [a]  [a]  [b] cross f xs ys = [ f x y | x  xs, y  ys ] cross f [ ] ys= cross f (x:xs) ys= [ ] map (f x) ys ++ cross f xs ys

17 Ontwerp van functies op lijsten nCombineer standaardfuncties nHerken je een,, of zoiets? Schrijf dan eerst de hulpfunctie nGebruik expliciete recursie mapfilterfoldr f [ ] =... f (x:xs) =... f xs...

18 Voorbeeld 1 nEen string afpassen op een gegeven lengte afkappen, of aanvullen met spaties precies :: Int  String  String precies n s | n < len= | n == len= | n > len= where len = length s take n s s s ++ replicate (n-len) ’_’

19 Voorbeeld 2 nEen heleboel strings afpassen op lengte > evenlang 4 [ ”aap”, ”noot”, ”weide” ] [ ”aap_”, ”noot”, ”weid” ] evenlang :: Int  [String]  [String] evenlang n xs = map f xs where f x = precies n x evenlang n xs = map (precies n) xs

20 Voorbeeld 3 nStrings even lang maken zonder afkappen > uniform [ ”aap”, ”noot”, ”weide” ] [ ”aap__”, ”noot_”, ”weide” ] uniform :: [String]  [String] uniform xs = evenlang n xs where n = maximum (map length xs)

21 Voorbeeld 4 nKolommen afpassen in blok van strings > unikol [[ ” aap ”,” noot ”,” mies ” ], [ ” wim ”,” zus ”,” jet ” ], [ ” weide ”,” hok ”,” schapen ”] ] [[ ” aap__ ”,” noot ”,” mies___ ” ], [ ” wim__ ”,” zus_ ”,” jet____ ” ], [ ” weide ”,” hok_ ”,” schapen ” ] ]

22 Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol xss= map uniform xss

23 Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol xss= map uniform xss

24 Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol =

25 Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol = wissel

26 Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol = map uniform. wissel

27 Kolommen uniformeren jetzuswim miesnootaap schapenhokweide unikol = wissel. map uniform. wissel

28 Wissel [1, 2][3, 4][5, 6][7, 8] [1, 3, 5, 7] [2, 4, 6, 8] [3, 5, 7] [4, 6, 8] [1, 2] wissel ( xs : xss ) = (wissel xss) xs zipWith (:)

29 Wissel wissel (xs : xss) = zipWith (:) xs (wissel xss) wissel [ ] = 3 rijen van elk 5 elementen  5 rijen van elk 3 elementen 2 rijen van elk 5 elementen  5 rijen van elk 2 elementen 1 rij van elk 5 elementen  5 rijen van elk 1 element 0 rijen van elk 5 elementen  5 rijen van elk 0 elementen veel oneindig repeat [ ] wissel = foldr......

30 Aanloop 1234 1 aanloop ( x : xs ) = (aanloop xs) x map ((:) ) [ ][1,2,3,4][1,2,3][1,2][1][ ][2,3,4][2,3][2] [ ] : :: [a]  [[a]]