hogere orde functies herhaald patroon parametrizeer n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Hogere-orde functies: herhaald patroon? Parametrizeer! PowerPoint Presentation
Download Presentation
Hogere-orde functies: herhaald patroon? Parametrizeer!

Loading in 2 Seconds...

play fullscreen
1 / 35

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


  • 101 Views
  • Uploaded on

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.

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

PowerPoint Slideshow about 'Hogere-orde functies: herhaald patroon? Parametrizeer!' - harper


An Image/Link below is provided (as is) to download presentation

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
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
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
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
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
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
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
Deel II

Boomstructurenin Haskell

binaire bomen

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
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; }

// bladeren gecodeerd met null

}

oo aanpak van bomen binaire bomen met externe data
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

}

functionele aanpak van bomen

Haskell notatie:

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

slide12

definition

declaration

type

Name

type

=

typ

type

var

constructor

operator

type

type

type

Name

constructor

Name

data

=

type

var

type

context

|

functies op bomen
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
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
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
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
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
Een datastructuur opschrijven
  • Lijst
  • Boom

[ ]

1 :

2 :

3 :

4 :

Tak 3 (

)

(

)

Tak 7 ( )

( )

Tak 4 Blad Blad

Tak 2

Blad

Blad

Tak 5 (Tak 1 Blad Blad )

(Blad )

een datastructuur opschrijven1
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
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 opschrijven2
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
Functies op Expressies

plus :: Expr  Expr  Expr

maal :: Expr  Expr  Expr

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

eenvoud :: Expr  Expr

plus = (:+:)

maal = (:+:)

functies op expressies1
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 expressies2
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 expressies3
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
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 bool eans
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 prop osities bewerken
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 prop osities
Functies op Proposities

typeBedeling = [(String,Bool)]

evalueer :: Bedeling  Prop  Bool

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

False

functies op prop osities1
Functies op Proposities

tautologie :: Prop  Bool

contradictie :: Prop  Bool

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

True

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

False

functies op prop osities2
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 prop osities3
Functies op Proposities

eenvoudig :: Prop  Prop

tautologieën en contradictiesvervangen door constanten

> 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 prop osities4
Functies op Proposities

normaalvorm :: Prop  Prop

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

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

Not alleen voor variabelen

functies op prop osities5
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 prop osities6
Functies op Proposities

evalueer :: Bedeling  Prop  Bool

tautologie :: Prop  Bool

contradictie :: Prop  Bool

equivalentie :: Prop  Prop  Bool

vervulbaar :: Prop  [Bedeling]

eenvoudig :: Prop  Prop

normaalvorm :: Prop  Prop

toon :: Prop  String

ontleed :: String  Prop