hoofdstuk 1

LOGISCH en
FUNCTIONEEL
PROGRAMMEREN
Ik zeg wat ik denk!
Opbouw
Deel 1: Functioneel programmeren
docent: Jeroen Fokker (informatica)
tot de kerstvakantie (week 47-51)
Deel 2: Logisch programmeren
docent: Louis des Tombe (letteren)
na de kerstvakantie (week 2-5)
deel 1:
Functioneel programmeren
H1
H2
H3.1
H3.2
H4
H5.1
H5.2
H5.2
App. A
Pr.1
tentamen Pr.2
Imperatief programmeren
Programma bestaat uit
opdrachten
gegroepeerd in methoden
Runnen is
één voor één uitvoeren
te beginnen met main
Functioneel programmeren
Programma bestaat uit
functie-definities
Runnen is
uitrekenen van een
expressie
Logisch programmeren
Programma bestaat uit
predicaat-definities
Runnen is
vervullen
van een predicaat
proberen te
Geschiedenis van
programmeertalen
Imperatief
1945
1950
1955
1960
1965
1970
1975
1980
1985
1990
1995
2000
Mach.taal
Assembler
Fortran
Algol
Basic
Pascal
Simula
C
C++
Java
C#
Functioneel
Logisch
Lisp
Prolog
Miranda
Scheme
Gofer
Haskell
Functie-definitie
static int kwad (int x)
{ return x*x ;
}
kwad :: Int  Int
kwad x = x * x
Haskell
Gebruik van de functie
public static void main(String [ ] ps)
{ System.out.println( this.kwad(5) );
}
main :: Int
main = kwad 5
Haskell
Compilers voor Haskell
 GHC (Glasgow Haskell
Compiler)
 Hugs (Haskell User’s
Gofer System)
 Helium
Helium
Compiler èn interpreter
Vereenvoudigd type-systeem
Begrijpelijke foutmeldingen
Utrechts
Gloednieuw
Experimenteel
Helium-interpreter
H:\> hi
> sqrt 2.0
1.41421
functie uit de
standaard prelude
Int - operatoren
>5+2*3
11
> sin 0.3 *. sin 0.3 +. cos 0.3 *. cos 0.3
1.0
Float - operatoren
Lijsten
Lijst: rijtje elementen van hetzelfde type
[ 1, 3, 8, 2, 5 ]
vierkante haken
[ 2 .. 6 ]
“tot en met”
Functies op lijsten
> sum [1 .. 10]
55
> reverse [3 .. 8]
[8, 7, 6, 5, 4, 3]
> length [1, 5, 9, 3]
4
> replicate 5 2
[2, 2, 2, 2, 2]
Zelf functies definiëren
module Statistiek where
fac n = product [1..n]
boven n k = fac n / (fac k * fac (n-k))
n! = 1*2*...*n
n!
n
=
k
k! (n-k)!
()
Functie-definitie
fac :: Int  Int
fac n = product [1..n]
static int fac (int n)
{ int tel, res;
res = 1;
for (tel=1; tel<=n; tel++)
res *= tel;
return res;
}
Haskell
Gebruik van functies
Met de interpreter
module Stat where
fac n = product [1..n]
H:\> hi
> :l Stat
> fac 6
720
Met de compiler
module Stat where
fac n = product [1..n]
main = fac 6
H:\> helium Stat.hs
H:\> lvmrun Stat
720
Soorten definities
Functie
fac :: Int  Int
fac n = product [1..n]
Constante
pi :: Float
pi = 3.1415926535
Operator
( !^! ) :: Int  Int  Int
n !^! k = fac n
/ (fac k * fac (n-k))
Prelude: functies op Int
Rekenkundige
operatoren
+ - * / ^
Vergelijkingsoperatoren
== /=
< <=
> >=
Functies
abs signum gcd
Prelude: functies op Float
Rekenkundige
operatoren
+. -. *. /. ^.
Vergelijkingsoperatoren
==. /=.
<. <=.
>. >=.
Functies
sqrt sin log exp
truncate
Prelude: functies op Bool
Logische
combinaties
Functies
&&
not
||
Prelude: operatoren op lijsten
 “op kop van”
:
> 1 : [2, 3, 4]
[1, 2, 3, 4]
 “samenvoegen”
> [1, 2] ++ [3, 4, 5]
[1, 2, 3, 4, 5]
++
Prelude: functies op lijsten
 “leeg?”
null
> null [ ]
True
“allemaal waar?”
and
> and [ 1<2, 2<3, 1==0]
False
“neem deel”
> take 3 [2..10]
[2, 3, 4]
take
Functies als parameter
Pas functie toe op alle
elementen van een lijst
map
> map fac [1, 2, 3, 4, 5]
[1, 2, 6, 24, 120]
> map sqrt [1.0, 2.0, 3.0, 4.0]
[1.0, 1.41421, 1.73205, 2.0]
> map even [1 .. 6]
[False, True, False, True, False, True]
Functies definiëren
Door 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
Functies met meer parameters
boven :: Int  Int  Int
boven n = fac n / (fac k * (fac (n-k))
met een lijst als resultaat
omtrekOppervl :: Int  Int  [Int]
omtrekOppervl len br = [ 2*(len+br)
, len*br
]
Hergebruik deel-formules
abc :: Float  Float  Float  [Float]
abc a b c = [ (-b + sqrt(b*b-4*a*c)) / (2*a)
, (-b - sqrt(b*b-4*a*c)) / (2*a)
]
geef de deelformules een naam
abc a b c = [ ( -b + d ) / n
, ( -b - d ) / n
]
where d = sqrt (b*b – 4*a*c)
n = 2*a
Gevallen onderscheiden
abs :: Int  Int
abs x | x>=0
| x<0
= x
= -x
“guards”
Herhalen
fac :: Int  Int
fac n
| n==0
| n>0
graag zonder
product te gebruiken
= 1
= n * fac (n-1)
“recursie”
Definitie met patronen
dag
dag
dag
dag
dag
dag
dag
dag
:: Int
1 =
2 =
3 =
4 =
5 =
6 =
7 =
 String
“maandag”
“dinsdag”
“woensdag”
“donderdag”
“vrijdag”
“zaterdag”
“zondag”
constante
als formele
parameter!
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
Patronen èn recursie
sum :: [Int]  Int
sum [ ]
= 0
sum (x:xs)
= x + sum xs
length :: [Int]  Int
length [ ]
= 0
length (x:xs) = 1 + length xs
Het type van length
[a] 
length :: [Int]
 Int
Int
“polymorf”
length [ ]
= 0
length (x:xs) = 1 + length xs
null :: [a]  Bool
head:: [a]  a
tail :: [a]  [a]
Publieksvraag:
Het type van map
> map fac [1, 2, 3, 4, 5]
[1, 2, 6, 24, 120]
> map even [1 .. 6]
[False, True, False, True, False, True]
map :: (ab)  [a]  [b]
Practicum
BBL
 zaal 408 en 412
(2 personen per computer)
Website
www.cs.uu.nl/docs/vakken/lfp