11

Funkcionális és logikai programozásFunkcionális és logikai programozás{ Márton Gyöngyvér, 201{ Márton Gyöngyvér, 20122}}

{ Sapientia, Erdélyi Magyar Tudományegyetem } { Sapientia, Erdélyi Magyar Tudományegyetem } http://www.ms.sapientia.ro/~mgyongyihttp://www.ms.sapientia.ro/~mgyongyi

`̀

22

Követelmények, osztályozásKövetelmények, osztályozás JelenlétJelenlét::

Az első 4 előadáson való részvétel plusz 1 pontot jelent a vizsgán.Az első 4 előadáson való részvétel plusz 1 pontot jelent a vizsgán. A laborgyakorlat kötelező, hiányzás esetén kötelező az óra pótlása, A laborgyakorlat kötelező, hiányzás esetén kötelező az óra pótlása,

ellenkező esetben csak a fizetéses vizsgán lehet részt venni. ellenkező esetben csak a fizetéses vizsgán lehet részt venni.

Vizsga (Kollokvium)Vizsga (Kollokvium):: A vizsga 9 pontos elméleti tételsorból áll.A vizsga 9 pontos elméleti tételsorból áll. A vizsgázás időpontja megegyezik az utolsó előadás időpontjával.A vizsgázás időpontja megegyezik az utolsó előadás időpontjával. Az összes laborfeladat bemutatása (max 2 hetes késéssel) 10-es Az összes laborfeladat bemutatása (max 2 hetes késéssel) 10-es

vizsgajegyet jelent.vizsgajegyet jelent. A vizsgán való részvétel követelménye, hogy a kitűzött labor A vizsgán való részvétel követelménye, hogy a kitűzött labor

feladatok 50%-ban legyenek leadva.feladatok 50%-ban legyenek leadva. Akik nem érik el a 7-es osztályzatot az elméleti vizsgán, azok Akik nem érik el a 7-es osztályzatot az elméleti vizsgán, azok

kötelező gyakorlati vizsgát kell tegyenek, mely közvetlenül az kötelező gyakorlati vizsgát kell tegyenek, mely közvetlenül az írásbeli után következik.írásbeli után következik.

A fizetéses vizsgán való részvételhez nem kötelező a A fizetéses vizsgán való részvételhez nem kötelező a laborfeladatok bemutatása.laborfeladatok bemutatása.

33

KönyvészetKönyvészet Funkcionális programozás:Funkcionális programozás:

Horváth Zoltán: Programnyelvek/ A funkcionális programozási Horváth Zoltán: Programnyelvek/ A funkcionális programozási nyelvek elemeinyelvek elemei

http://www.cs.ru.nl/~clean/http://www.cs.ru.nl/~clean/ http://people.inf.elte.hu/csz/0506/funkimp.htmlhttp://people.inf.elte.hu/csz/0506/funkimp.html

Logikai programozás:Logikai programozás: Szeredi Péter, Benkő Tamas: Deklaratív programozás, oktatási Szeredi Péter, Benkő Tamas: Deklaratív programozás, oktatási

segédletsegédlet Ásványi Tibor: A logikai programozás és a PrologÁsványi Tibor: A logikai programozás és a Prolog Peter Flach: Logikai programozásPeter Flach: Logikai programozás J.M.Spivey: An introduction to logic programming through PrologJ.M.Spivey: An introduction to logic programming through Prolog http://www.swi-prolog.org/http://www.swi-prolog.org/ http://aszt.inf.elte.hu/~asvanyi/pl/jegyzetekhttp://aszt.inf.elte.hu/~asvanyi/pl/jegyzetek

ELTE:ELTE:http://people.inf.elte.hu/divip/http://people.inf.elte.hu/divip/ BME: BME: http://dp.iit.bme.huhttp://dp.iit.bme.hu

44

Funkcionális és logikai programozáshoz Funkcionális és logikai programozáshoz szükséges install állományok, windows alá, a belső szükséges install állományok, windows alá, a belső hálózaton, az alábbi szerverenhálózaton, az alábbi szerveren

Funkcionális programozás ( Clean2.1.1 )Funkcionális programozás ( Clean2.1.1 )\\kelemen\Kit\Programozás\Clean2.1.1\\kelemen\Kit\Programozás\Clean2.1.1

Logikai programozás ( Prolog )Logikai programozás ( Prolog )\\kelemen\Kit\Programozás\Prolog\\kelemen\Kit\Programozás\Prolog

Funkcionális és logikai programozáshoz Funkcionális és logikai programozáshoz szükséges segédanyag, a belső hálózaton: szükséges segédanyag, a belső hálózaton:

\\kelemen\TanaroktolDiakoknak\MartonGy\Funkcionális\\kelemen\TanaroktolDiakoknak\MartonGy\Funkcionális\\kelemen\TanaroktolDiakoknak\MartonGy\Logikai\\kelemen\TanaroktolDiakoknak\MartonGy\Logikai

55

BevezetőBevezetőFunkcionális programozás Clean 2.1. 1. környezetben Funkcionális programozás Clean 2.1. 1. környezetben

JellemzőkJellemzők ListákListák Magasabb rendű függvényekMagasabb rendű függvények OperátorokOperátorok Adatszerkezetek, algoritmusokAdatszerkezetek, algoritmusok I/O I/O műveletekműveletek AlgoritmusokAlgoritmusok hatékonyságahatékonysága Eseménykezelés, grafikus felületEseménykezelés, grafikus felület Hálózati kommunikációHálózati kommunikáció

Logikai programozás Prolog környezetben, bevezetőLogikai programozás Prolog környezetben, bevezető Alapfogalmak: aritmetika, listák, operátorokAlapfogalmak: aritmetika, listák, operátorok AlgoritmusokAlgoritmusok I/O I/O műveletekműveletek

TémakörökTémakörök

66

BevezetőBevezető Programozási módszerek:Programozási módszerek:

imperatív programozásimperatív programozás programozási nyelvek: assembly, Java, C, C++, programozási nyelvek: assembly, Java, C, C++, alapeszköze: a ciklus utasításalapeszköze: a ciklus utasítás

deklaratív programozásdeklaratív programozás Funkcionális programozásFunkcionális programozás

programozási nyelvek: Lisp, Haskell, Clean programozási nyelvek: Lisp, Haskell, Clean alapeszköze: a függvényalapeszköze: a függvény

Logikai programozásLogikai programozás programozási nyelvek: Prolog, SQLprogramozási nyelvek: Prolog, SQL alapeszköze: a reláció -tények, szabályokalapeszköze: a reláció -tények, szabályok

77

az imperatív programozás sajátosságai:az imperatív programozás sajátosságai:

felszólító mód: parancsok, utasításokfelszólító mód: parancsok, utasítások a lényeg az algoritmus megtalálása ( hogyan oldjuk meg a a lényeg az algoritmus megtalálása ( hogyan oldjuk meg a

feladatot) feladatot) pontosan követhetőek a végrehajtott lépésekpontosan követhetőek a végrehajtott lépések a változó: egy adott memória helyen tárolt aktuális érték, a változó: egy adott memória helyen tárolt aktuális érték,

mely ismételten újabb és újabb értéket vesz felmely ismételten újabb és újabb értéket vesz fel

88

a deklaratív programozás sajátosságaia deklaratív programozás sajátosságai::

kijelentő mód: állítások, egyenletekkijelentő mód: állítások, egyenletek a lényeg: az algoritmus leírása ( mit kell megoldanunk )a lényeg: az algoritmus leírása ( mit kell megoldanunk ) a végrehajtás, a nyelv értelmező, fordító programjától függa végrehajtás, a nyelv értelmező, fordító programjától függ nem mindig követhetőek a végrehajtott lépéseknem mindig követhetőek a végrehajtott lépések a változó: a matematikából ismert fogalomnak felel meg, a változó: a matematikából ismert fogalomnak felel meg,

tulajdonképpen egytulajdonképpen egy ismeretlen, ami segítségével felírjuk az ismeretlen, ami segítségével felírjuk az adott relációt, rekurzív összefüggéstadott relációt, rekurzív összefüggést

alkalmazási terület: Cad rendszerek, telekommunikáció, alkalmazási terület: Cad rendszerek, telekommunikáció, mesterséges intelligenciamesterséges intelligencia

99

C kód:C kód: 1 változat1 változat ::int faktint fakt00 ( int n ) { ( int n ) {

int i, int i, resres;;if ( n<if ( n<00 ) return ) return --1;1;if ( nif ( n==0==0 ) return 1; ) return 1;for( i=1, for( i=1, resres=1; i<=n; i++)=1; i<=n; i++)

resres *= i; *= i;return return resres;;

}} 2 változat:2 változat:int faktint fakt11 ( int n ) { ( int n ) {

if ( n<if ( n<00 ) return ) return --1;1;if ( nif ( n====00 ) return 1; ) return 1;else return n * faktelse return n * fakt11(n-1);(n-1);

}}

33 változat: változat:int faktint fakt22 ( ( int res, int res, int n) {int n) {

if ( n<if ( n<00 ) return ) return --1;1;if ( nif ( n====00 ) return ) return resres;;return return ffaktakt22((n*res , n*res , n-1);n-1);

}}

függvény hívásfüggvény hívásokok: : X = faktX = fakt00 (10); (10);X = faktX = fakt11 (10); (10);X = faktX = fakt22 ( (1, 1, 10);10);

1010

Clean kód:Clean kód: 1 változat1 változat ::

fakt1 :: Int -> Intfakt1 :: Int -> Intfakt1 0 = 1 fakt1 0 = 1

fakt1 n = n * fakt1 (n-1)fakt1 n = n * fakt1 (n-1)

függvény hívás: függvény hívás: Start = fakt1 10Start = fakt1 10

22 változat változat ::fakt2 :: Int -> Intfakt2 :: Int -> Intfakt2 n fakt2 n

| n < 0 = -1| n < 0 = -1| n == 0 = 1| n == 0 = 1

= n * fakt2 (n-1)= n * fakt2 (n-1)

függvény hívás: függvény hívás: Start = fakt2 10Start = fakt2 10

33 változat: változat:fakt3 :: Int Int -> Intfakt3 :: Int Int -> Intfakt3 res nfakt3 res n

| n < 0 = -1| n < 0 = -1| n == 0 = res| n == 0 = res

= fakt3 (n*res) (n-1)= fakt3 (n*res) (n-1)

függvény hívás: függvény hívás: StartStart = fakt = fakt33 1 1 1010

1111

Prolog kód:Prolog kód: fakt(0, 1).fakt(0, 1).fakt(N, Res) :-fakt(N, Res) :- N >0,N >0, N1 is N - 1,N1 is N - 1, fakt(N1, Res1),fakt(N1, Res1), Res is N * Res1.Res is N * Res1.

a a formula formula kiértékelésekiértékelése::fakt(10, X).fakt(10, X).

1212

Funkcionális programozás Funkcionális programozás Clean 2.1.1. környezetbenClean 2.1.1. környezetben

1313

feltételek megadása ( definition by cases ) : a függvény értékét feltételek megadása ( definition by cases ) : a függvény értékét az első, igaz egyenlőséghez tartozó kifejezés adja, mely az első, igaz egyenlőséghez tartozó kifejezés adja, mely kifejezést az aktuális paraméter értéke alapján kapjukkifejezést az aktuális paraméter értéke alapján kapjuk

Pl: az argumentum előjelének a meghatározásaPl: az argumentum előjelének a meghatározása

alapok1.iclalapok1.iclmodule alapok1module alapok1import StdEnvimport StdEnv

signum :: Int -> Intsignum :: Int -> Intsignum xsignum x| x < 0 = -1| x < 0 = -1| x > 0 = 1| x > 0 = 1| x == 0 = 0| x == 0 = 0

Start = signum -10Start = signum -10

JellemzőkJellemzők

1414

rekurzivitás ( definition by recursion ): a függvények rekurzivitás ( definition by recursion ): a függvények hivatkozhatnak önmagukra és kölcsönösen egymásrahivatkozhatnak önmagukra és kölcsönösen egymásra

Pl: két egész szám legnagyobb közös osztójának a Pl: két egész szám legnagyobb közös osztójának a meghatározásameghatározása

lnko :: Int Int -> Intlnko :: Int Int -> Intlnko a blnko a b

| a > b = lnko (a-b) b| a > b = lnko (a-b) b| a < b = lnko a (b-a)| a < b = lnko a (b-a)| a == b = a| a == b = a

Start = lnko 18 56Start = lnko 18 56

1515

az argumentumok mintaillesztése ( definition by patterns ): a az argumentumok mintaillesztése ( definition by patterns ): a függvény értékét az a függvénytörzs határozza meg, amelyre a függvény értékét az a függvénytörzs határozza meg, amelyre a formális paraméter egy megadott minta alapján illeszkedikformális paraméter egy megadott minta alapján illeszkedik

Pl1: egy három elemű lista Pl1: egy három elemű lista elemeinek összeadása elemeinek összeadása

osszeg :: [Int] -> Intosszeg :: [Int] -> Intosszeg [] = 0osszeg [] = 0osszeg [x] = x osszeg [x] = x osszeg [x,y] = x+yosszeg [x,y] = x+yosszeg [x,y,z] = x+y+zosszeg [x,y,z] = x+y+z

//futási hibát ad//futási hibát adStart = osszeg [2,3,4,5]Start = osszeg [2,3,4,5]

Pl2: egy szám számjegyeinek Pl2: egy szám számjegyeinek összegeösszege

isum :: Int -> Intisum :: Int -> Intisum 0 = 0isum 0 = 0isum szam = ( szam rem 10 ) isum szam = ( szam rem 10 )

+ isum (szam /10)+ isum (szam /10)

Start = isum 123Start = isum 123

a mintaillesztést és a feltételek megadását lehet együttesen a mintaillesztést és a feltételek megadását lehet együttesen alkalmaznialkalmazni

1616

szigorú, statikus típusosság : a kifejezések típusát a szigorú, statikus típusosság : a kifejezések típusát a fordítóprogram meghatározza úgy is, ha nincs az feltüntetvefordítóprogram meghatározza úgy is, ha nincs az feltüntetve

Pl: az argumentum abszolut értékének a meghatározásaPl: az argumentum abszolut értékének a meghatározása

abszolut xabszolut x| x < 0 = ~x //az x értékének a negáltja| x < 0 = ~x //az x értékének a negáltja= x= x

Start = abszolut -10Start = abszolut -10

abszolut :: Int -> Intabszolut :: Int -> Int abszolut :: Real -> Realabszolut :: Real -> Realabszolut xabszolut x abszolut xabszolut x| x < 0 = ~x | x < 0 = ~x | x < 0| x < 0.0.0 = ~x = ~x = x= x = x= x

abszolut :: a -> a | zero, <, ~ aabszolut :: a -> a | zero, <, ~ aabszolut xabszolut x

| x < zero = ~x | x < zero = ~x = x= x

1717

Zermelo-Fraenkel halmazkifejezések: iteratív adatszerkezetek Zermelo-Fraenkel halmazkifejezések: iteratív adatszerkezetek (listák, halmazok, sorozatok) elemeinek megadására (listák, halmazok, sorozatok) elemeinek megadására alkalmazott jelölésrendszeralkalmazott jelölésrendszer

Pl: Pl: egy szam osztóink a sorozataegy szam osztóink a sorozata

osztok :: Int -> [ Int ]osztok :: Int -> [ Int ]osztok n = [ i \\ i <- [1..n] | n rem i ==0]osztok n = [ i \\ i <- [1..n] | n rem i ==0]

Start = osztok 100Start = osztok 100

1818

speciális kifejezések: #, (let-before expression)speciális kifejezések: #, (let-before expression) az imperatív programozási stílushoz hasonló szerkezetaz imperatív programozási stílushoz hasonló szerkezet egy feltétel, vagy a függvénytörzs előtt definiálhatóegy feltétel, vagy a függvénytörzs előtt definiálható alkalmazható amikor a kiértékelési sorrend jól meghatározottalkalmazható amikor a kiértékelési sorrend jól meghatározott

Pl. Pl. gyok :: Real Real Real -> (Real, Real)gyok :: Real Real Real -> (Real, Real)gyok a b c gyok a b c

#delta = sqrt(b*b-4.0*a*c)#delta = sqrt(b*b-4.0*a*c)#d = 2.0*a#d = 2.0*a= ( (~b + delta) / d, (~b - delta) / d )= ( (~b + delta) / d, (~b - delta) / d )

Start = gyok 1.0 2.0 1.0Start = gyok 1.0 2.0 1.0

Megjegyzés: az sqrt könyvtárfüggvényMegjegyzés: az sqrt könyvtárfüggvény

1919

margó szabály: az összetartozó kifejezések meghatározására a margó szabály: az összetartozó kifejezések meghatározására a baloldali margó változtatását kell alkalmaznibaloldali margó változtatását kell alkalmazni

PL.: másodfokú egyenlet gyökeinek a meghatározásaPL.: másodfokú egyenlet gyökeinek a meghatározása

gyok :: Real Real Real -> (Real, Real)gyok :: Real Real Real -> (Real, Real)gyok a b c = ( (~b + delta) / d, (~b - delta) / d )gyok a b c = ( (~b + delta) / d, (~b - delta) / d )

where where deltadelta = sqrt(b*b-4.0*a*c) = sqrt(b*b-4.0*a*c)d = 2.0*ad = 2.0*a

deltadelta a = 3*a a = 3*a

Start = gyok 1.0 2.0 1.0Start = gyok 1.0 2.0 1.0

Melyik delta kifejezés értékelődik ki?Melyik delta kifejezés értékelődik ki?Start = delta 2Start = delta 2

2020

különböző típusok együttes alkalmazásakülönböző típusok együttes alkalmazása

Pl. Pl. gyok :: Real Real Real -> (String, [Real])gyok :: Real Real Real -> (String, [Real])gyok a b c gyok a b c

#delta = sqrt(b*b-4.0*a*c)#delta = sqrt(b*b-4.0*a*c)#d = 2.0*a#d = 2.0*a|delta < 0.0 = ("komplex gyokok", [])|delta < 0.0 = ("komplex gyokok", [])|delta == 0.0 = ("egy gyok", [~b/d])|delta == 0.0 = ("egy gyok", [~b/d])= ("ket gyok", [ (~b + delta) / d, (~b - delta) / d ])= ("ket gyok", [ (~b + delta) / d, (~b - delta) / d ])

Start = gyok 1.0 3.0 1.0Start = gyok 1.0 3.0 1.0

2121

magasabb rendű függvények ( high order function ) Imagasabb rendű függvények ( high order function ) I argumentumuk lehet függvényargumentumuk lehet függvény visszatérítési értékük lehet függvény, mely más függvénynek is visszatérítési értékük lehet függvény, mely más függvénynek is

szolgálhat argumentumulszolgálhat argumentumul

PPll 1 1. . my_inc x = x+1my_inc x = x+1my_twice f x = f (f x)my_twice f x = f (f x)Start = my_twice my_inc 0Start = my_twice my_inc 0

Pl 2.Pl 2.Start = map sqrt [ 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]Start = map sqrt [ 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ]

Megjegyzés: Megjegyzés: a a map könyvtárfüggvény, kétkönyvtárfüggvény, két argumentumaargumentuma van: az els van: az első ő egy függvény, melyet alkalmaz a listaként megadott második egy függvény, melyet alkalmaz a listaként megadott második argumentumáraargumentumára