Hogere-orde functies: herhaald patroon? Parametrizeer!

1 / 35

# Hogere-orde functies: herhaald patroon? Parametrizeer! - PowerPoint PPT Presentation

Hogere-orde functies: herhaald patroon? Parametrizeer!. product :: [Int]  Int. 1. product [ ] = product (x:xs) =. product xs. x. *. and :: [Bool]  Bool. True. and [ ] = and (x:xs) =. and xs. x. &&. sum :: [Int]  Int. 0.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## Hogere-orde functies: herhaald patroon? Parametrizeer!

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Hogere-orde functies:herhaald patroon? Parametrizeer!

product :: [Int]  Int

1

product [ ] =product (x:xs) =

product xs

x

*

and :: [Bool]  Bool

True

and [ ] =and (x:xs) =

and xs

x

&&

sum :: [Int]  Int

0

sum [ ] =sum (x:xs) =

sum xs

x

+

Universele lijst-loper: foldr

foldr :: [a]  a

(aaa) 

a 

foldr :: (abb) b  [a]  b

combineer-functie

start-waarde

foldr (#) e [ ] =foldr (#) e (x:xs)=

e

foldr (#) e xs

x

#

Partiële parametrizatie
• foldr is een generalisatievan sum, product, en and ....
• …dus sum, product, en andkun je schrijven met foldr

product = foldr (*) 1

and = foldr (&&) True

sum = foldr (+) 0

or = foldr (||) False

Voorbeeld: sorteren (1/2)

insert :: a  [a]  [a]

insert e [ ] = [ e ]

insert e (x:xs)

| e  x = e : x : xs

| e  x = x : insert e xs

Ord a

isort :: [a]  [a]

isort [ ] = [ ]

isort (x:xs) = insert x (isort xs)

Ord a

isort = foldr insert [ ]

Voorbeeld: sorteren (2/2)

qsort :: [a]  [a]

qsort [ ] = [ ]

qsort (x:xs) = qsort (filter (<x) xs)

++ [x] ++

qsort (filter (x) xs)

Ord a

(Waarom hebben ze me nooit eerder verteld dat ‘t zo makkelijk is?)

Handige notaties(geleend uit de wiskunde)
• Lambda abstractie
• Lijst comprehensie

Om naamloze functies te maken

\x  x*x

[ x*y | x  [1..10]

, even x

, y  [1..x]

]

intuitiever dan combinatievan map , filter & concat

Deel II

6

34

26

18

8

5

11

14

3

10

29

15

23

4

1

Binaire bomen

met interne waarden

Hoe codeer je datin Java/C++/C# enz?

OO-aanpak van bomen

class Tree

{ private Tree left, right; private int value;

// constructor

public Tree(Tree al, Tree ar, int av)

{ left = al; right=ar; value=av; }

}

OO-aanpak van bomen:binaire bomen met externe data

class Tree {

// lege superclass}

class Leaf extends Tree {

int value

}

class Node extends Tree {

Tree left,right

}

dataTree a

= Leaf a | Node (Tree a) (Tree a)

Functionele aanpak van bomen

Tree a

• Ik wil een polymorf type
• En constructorfuncties

Leaf :: a  Tree a

Node :: Tree a  Tree a  Tree a

definition

declaration

type

Name

type

=

typ

type

var

constructor

operator

type

type

type

Name

constructor

Name

data

=

type

var

type

context

|

Functies op bomen
• Naar analogie van lijst-functies
• schrijf je een functie op een boom:

length :: [a]  Int

length [ ] = 0

length (x:xs) = 1 + length xs

size :: Tree a  Int

size (Leaf v) = 1

size (Node lef rit) = size lef + size rit

Uitdaging: schrijf boom-functies
• elem kijkt of een waarde in een boom zit
• front verzamelt alle waarden in een lijst

elem :: a  Tree a  Bool

elem x (Leaf y) = x==y

elem x (Node lef rit) = elem x lef || elem x rit

Eq a

front :: Tree a [a]

front (Leaf y) = [ y ]

front (Node lef rit) = front lef ++ front rit

Toepassing: expressies

(3*a + 4*b) / c

typeExpr =

plus :: Expr  Expr  Expr

maal :: Expr  Expr  Expr

waarde :: [(String,Int)]  Expr  Int

eenvoud :: Expr  Expr

Expressies: poging 1

(3*a + 4*b) / c

typeExpr =

String

3+a

4+b

*

plus :: Expr  Expr  Expr

waarde :: [(String,Int)]  Expr  Int

plus a b = a ++ “+” ++ b

waarde tab s = foldr ??? ??? s

Expressies: poging 2

dataExpr

=

|

|

|

|

|

Con

Var

Plus

Min

Maal

Deel

Int

String

Expr Expr

Expr Expr

Expr Expr

Expr Expr

constructorfuncties

waarmee je een Expr bouwt

types van de parametersdie daarbij nodig zijn

Een datastructuur opschrijven
• Lijst
• Boom

[ ]

1 :

2 :

3 :

4 :

Tak 3 (

)

(

)

Tak 7 ( )

( )

Tak 2

Een datastructuur opschrijven

(3*a + 4*b) / c

• Expr

(Maal (Con 3) (Var “a”))

(Maal (Con 4) (Var “b”))

Deel

(

)

( Var “c” )

Plus

Expressies: poging 3

dataExpr

=

|

|

|

|

|

Constructorenbeginnen methoofdletter

of dubbelepunt

Int

String

Expr Expr

Expr Expr

Expr Expr

Expr Expr

Con

Var

:+:

:-:

:*:

:/:

constructorfuncties/operatoren

waarmee je een Expr bouwt

constructorfuncties

waarmee je een Expr bouwt

Een datastructuur opschrijven

(3*a + 4*b) / c

• Expr

Con 3 :*: Var “a”

Con 4 :*: Var “b”

(

) :/: ( Var “c” )

:+:

infixl 6 (:+:), (:-:)

infixl 7 (:*:), (:/:)

Functies op Expressies

plus :: Expr  Expr  Expr

maal :: Expr  Expr  Expr

waarde :: [(String,Int)]  Expr  Int

eenvoud :: Expr  Expr

plus = (:+:)

maal = (:+:)

Functies op Expressies

wrd :: [(String,Int)]  Expr  Int

wrd t (Con n)

wrd t (Var v)

wrd t (a:+:b)

wrd t (a:-:b)

wrd t (a:*:b)

wrd t (a:/:b)

=

=

=

=

=

=

n

zoekop t v

wrd t a + wrd t b

wrd t a – wrd t b

wrd t a * wrd t b

wrd t a / wrd t b

Functies op Expressies

afg :: Expr  String  Expr

“de afgeleide

naar eenvariabele”

afg (Con c) dx

afg (Var v) dx

= Con 0

| eqString v dx = Con 1

| otherwise = Con 0

afg (a:+:b) dx

afg (a :-:b) dx

= afg a dx :+: afg b dx

= afg a dx :-: afg b dx

Functies op Expressies

afg :: Expr  String  Expr

= a :*: afg b dx :+:

b :*: afg a dx

afg (a:*:b) dx

afg (a :/:b) dx

= ( b :*: afg a dx :-:

a :*: afg b dx

)

:/: (b :*: b)

Twee soorten berekening
• Numeriek
• Symbolisch

diff :: (FloatFloat)  (FloatFloat)

diff f x = (f (x+h) – f x) / h

where h = 0.00001

dat is nou AI!

afg :: Expr  String  Expr

afg (Con c) dx = Con 0

afg (Var v) dx | eqString v dx = Con 1

|otherwise = Con 0

afg (a:+:b) dx = afg a dx :+: afg b dx

afg (a:*:b) dx = a :*: afg b dx :+: b :*: afg a dx

Rekenen met Booleans

(&&) :: Bool  Bool  Bool

(||) :: Bool  Bool  Bool

not :: Bool  Bool

True && y = y

False && y = False

True || y = True

False || y = y

not True = False

not False = True

Symbolisch Propositiesbewerken

dataProp

=

|

|

|

|

|

Bool

String

Prop

Prop Prop

Prop Prop

Prop Prop

Con

Var

Not

:/\

:\/

:->

constructorfuncties/operatoren

waarmee je een Prop bouwt

constructorfuncties

waarmee je een Expr bouwt

Functies op Proposities

typeBedeling = [(String,Bool)]

evalueer :: Bedeling  Prop  Bool

> evalueer [ (“p”,True), (“q”, False) ] (Var “p” :/\ Var “q”)

False

Functies op Proposities

tautologie :: Prop  Bool

> tautologie (Var “p” :\/ Not (Var “p”))

True

> contradictie (Var “p” :-> Var “q” )

False

Functies op Proposities

equivalentie :: Prop  Prop  Bool

vervulbaar :: Prop  [Bedeling]

> vervulbaar (Var “p” :-> Var “q” )

[ [ (“p”,True) , (“q”,True) ]

, [ (“p”,False) , (“q”, False) ]

, [ (“p”,False) , (“q”, True) ] ]

Functies op Proposities

eenvoudig :: Prop  Prop

> eenvoudig Not(Not (Var “p” :/\ (Var “q” :\/ Not Var “q”))

Not (Not (Var “p” :/\ Con True))

Not (Not (Var “p”))

Var “p”

operatoren met constanteparameters wegwerken

dubbele Not

wegwerken

Functies op Proposities

normaalvorm :: Prop  Prop

> normaalvorm (Not (Not Var “p” :\/ Var “q” )

Var “p” :/\ Not Var “q”

Not alleen voor variabelen

Functies op Proposities

toon :: Prop  String

ontleed :: String  Prop

> putStr (toon (Var “p” :-> Var “q”))

p -> q

> ontleed “p && !p”

Var “p” :/\ Not Var “p”

Functies op Proposities

evalueer :: Bedeling  Prop  Bool

tautologie :: Prop  Bool