Funkcionālā programmēšana (DIP330)

Lekciju materiāls sagatavots projekta“RTU akadēmiskās studiju programmas “Datorsistēmas” kursu pilnveidošana” ietvaros

©RTU, 2006

Funkcionālā Funkcionālā programmēšana (DIP330)programmēšana (DIP330)

2RTU akadēmiskās studiju programmas “Datorsistēmas” kursu pilnveidošana2005/0125/VPD1/ESF/PIAA/ 04/APK/3.2.3.2/0062/0007

V. Šitikovs. Funkcionālā programmēšana

Funkcionālā programmēšanaFunkcionālā programmēšana

Asociētais profesors, Dr.sc.ing. Vjačeslavs Šitikovs

Rīgas Tehniskā universitāteDatorzinātnes un informācijas tehnoloģijas fakultāteLietišķo datorsistēmu institūtsLietišķo datorsistēmu programmatūras profesora grupa



Priekšmeta pamatdatiPriekšmeta pamatdati

• Priekšmeta pieteicējs: Vjačeslavs Šitikovs• Apjoms: 2 KP• Kontroles veids: Eksāmens; Studiju darbs• Studiju līmenis: Akadēmiskā bakalaura

studiju programma• Semestris: 5. semestris



Priekšmeta mērķi un uzdevumiPriekšmeta mērķi un uzdevumi

• Mērķi:– Funkcionāla pieeja algoritmu izstrādei. Rekursīva pieeja funkciju

aprakstam. Problēmu risināšana sakot no gaidāma rezultāta. Programmatūras rīku izvēle specifiskas problēmas risināšanai.

• Uzdevumi:– Apgūt konkrēto funkcionālas programmēšanas valodas LISP

pamatus sagatavot pirmo nesarežģīto programmu (sarakstu apstrāde).

– Apgūt valodas LISP realizācijas LispWorks pamatus praktiski, izpildot pirmo programmu. Mērījums – strādājoša programma un atskaite.

– Apgūt daudzlīmeņu sarakstu rekursīvo apstrādi. Mērījums – strādājoša programma un atskaite.

– Apgūt sarežģīto problēmu risināšanu, kurai vispiemērotākā ir funkcionāla rekursīva pieeja. Mērījums – atskaite par studijas darbu, tas aizstāvēšana un atzīme.



PamatliteratūraPamatliteratūra

• Šitikovs V. “Programmēšanas valoda LISP. Lekciju konspekts“ // RTU, 2002, 36 lpp.– Valodas LISP īss apraksts ar piemēriem un

paskaidrojumiem.

• Šitikovs V. “Programmēšanas valoda LISP. Lekciju konspekts“ // RTU, 2002 / Internet - http://www.cs.rtu.lv/PubsLoc/Sitikovs /saturs.htm– Valodas LISP īsa apraksta Internet-versija ar

piemēriem un paskaidrojumiem.



PapildliteratūraPapildliteratūra

• Маурер У. Введение в программирование на языке ЛИСП. – М.: Мир, 1976. – 104.– Valodas LISP īss apraksts ar piemēriem un paskaidrojumiem

krievu valodā.

• Graham P. “On Lisp. Advanced Techniques for Common Lisp”// Prentice Hall, 1993, 432 pages (free download from http://www.paulgraham.com/onlisptext.html).– Valodas LISP detalizēts apraksts.

• Schwarz M. „LISP Tutorial“ / Internet. - http://cs1.cs.nyu.edu/phd_students/schwarz/NLCP/lisp.html– Valodas LISP detalizēta apraksta interaktīva versija.



Atslēgas vārdiAtslēgas vārdi

• Nealgoritmiska programmēšanas valoda

• Funkciju valoda• Sarakstu apstrādāšana• Rekursija• Rekursīvas funkcijas• Funkciju noteikšana• Nealgoritmiskās un algoritmiskās

pieejas kombinācija



Pamattēmas (1)Pamattēmas (1)

• Ievads. Valodas apraksts – alfabēts, pamatkonstrukcijas (atomi, saraksti, izteiksmes, apakšsaraksti).

• Rekursija. Tieša un netieša rekursija. Cikliskas un rekursīvas pieejas salīdzinājums.

• Funkciju izveidošana – sintakse, semantika, pieejas, paņēmieni, parametri.

• Funkcijas sarakstu apstrādei. Ievade-izvade. Interaktīvas funkcijas

• Predikāti un to pielietošana sarakstu apstrādei.• Nosacījuma izteiksmes, nosacījuma funkcijas.• Rekursīvas funkcijas – sarakstu rekursīvā apstrāde,

apakšsaraksti un rekursija, rekursīvie predikāti.



Pamattēmas (2)Pamattēmas (2)

• Loģiskie operatori un to pielietošana sarakstu apstrādei.• Rekursīvās funkcijas no diviem sarakstiem.• Funkcijas tipu izzināšanai. Argumentu validācija.• PROG-izteiksmes – apraksti, operatori, iezīmes, vadības

nodošana, nosacījuma izteiksmes, vērtības atgriešana. PROG- izteiksmes sarakstu apstrādei, sarakstu veidošana.

• Funkcijas darbība.• Predikāti, kuri uzrakstīti ar PROG palīdzību.• Rekursija PROG-izteiksmēs.• Funkciju apvienošana.• Izskaitļošanas noteikums, izskaitļojoša funkcija.• Programma kā dati.



Ievads (1)Ievads (1)

• Visu programmēšanas valodu kopu var sadalīt:– algoritmiskās jeb imperatīvās (instrukciju

valodās) – nealgoritmiskās

• Algoritmiskās– norādīta nepieciešamā darbību secība

– universālas programmēšanas valodas• Pascal, C, Basic u.t.t.




• Speciālu uzdevumu risināšanā– GPSS - vispārējas apkalpošanas

sistēmu modelēšanai– PROLOG - teorēmu pierādījuma tipa

uzdevumiem– LISP - dialoga realizēšanai valodā,

kura ir tuva dabīgai valodai




• LISP– saīsinājums no LISt Processing -

sarakstu apstrādāšana– nealgoritmiska programmēšanas

valoda– funkcionāla programmēšanas valoda




Imperatīva valoda

Input (a,b)c := a + bPrint (c)

Sākums -> Vidus-> Nobeigums

Funkcionāla valoda

Print (Plus Input() Input() )

Nobeigums ( Vidus (Sākums) )




• LISP– Džona Maikarta vadībā– Masačūsetas tehnoloģiskajā institūtā– 1960.gadā– lai aprakstītu simbolisko izteiksmju

rekursīvās funkcijas




• LISP– funkciju valoda– katra konstrukcija, kura ir uzrakstīta

valodā LISP, tiek apskatīta kā funkcija•(A B C) ir A(B,C)•sin x

– algoritmiskā valodās izskatās kā sin(x)– valodā LISP kā (sin x)




• Valodā LISP izņēmumu nav– x + y

•tiek pierakstīts kā (+ x y)

• Par funkcijas argumentu var būt citas funkcijas rezultāts– (A+B)*(C+D)

• tiek pierakstīts kā (*(+ A B)(+ C D))



Valodas apraksts (1)Valodas apraksts (1)

• Alfabēts– burti– cipari– ierobežotāji

•( - kreisā apaļā iekava•) - labā apaļā iekava•_ - intervāls

• Litera - drukāta zīme no alfabēta




• Atoms – patvaļīga literu secība, kura atrodas

starp diviem ierobežotājiem un pie kuras nepieder paši ierobežotāji

– konstrukcijā (A(ATOM X24)-ABC(-10 2.5)) atomi ir• A ATOM X24 -ABC -10 2.5




• Atomi– konstantes– identifikatori

•mainīgie•funkciju vārdi•jāsākas ar burtu un tam jāsastāv tikai no

burtiem un cipariem•nav ierobežojumu mainīgā vārda

garumam




• Rezervēti identifikatori– T - patiess (true),– F - nepatiess (false),– NIL - tukšums, kurš bieži tiek lietots

“nepatiess” vietā




• Mainīgajam var būt vērtība• Viens no vērtību piešķiršanas veidiem

– izmantojot funkciju SETQ •(SETQ X 5) analoģiski X:=5•(SETQ X (+ Y 1)) analoģiski x:=y+1•(SETQ X Y) analoģiski x:=y•(SETQ X (QUOTE Y)) analoģiski x:=“y”

– (SETQ X ‘Y)




• SETQ– netieši tiek izmantota funkcija QUOTE– piešķires funkcija SET

•(SET X Y) nozīme ka vērtībai X tiek piešķita Y vērtība

– Ja X ir vienāds ar 3 un Y ir vienāds ar 6, tad funkcija SET piešķirt skaitlim 3 skaitļa 6 vērtību, kas ir bezjēdzība

– (SET(QUOTE X) Y) vai (SETQ X Y)•piešķir mainīgajam X vērtību 6




• Ja X vērtība ir simbols Z– (SET X Y) ievieto mainīgajā Z

mainīgā Y vērtību•analoģiski z:=y




• Saraksti– elementu secība, kura ietverta apaļās iekavās– saraksta elements - atoms vai saraksts– saraksta elementu atdalītāji – intervāli

• Atdalītājs ir nepieciešams, ja abi saraksta blakus elementi ir atomi.

– Sarakstu piemēri• (A B C D) • (x) ((((100)))) (1(2 3)4)• () - tukšs saraksts




• Izteiksme ir atoms vai saraksts– Dažām izteiksmēm var būt vērtības

•Izteiksmes vērtība arī var būt izteiksme– Izteiksmes, kurām var būt vērtība

•konstantes, mainīgie•saraksti

– griešanās pie funkcijām» (P Q R) ir funkcijas P vērtība no

argumentiem Q un R» (G) - funkcija bez argumentiem




• Ir tikai viens konstrukcijas veids, kas tiek izskatīts valodā LISP – tās ir funkcijas

• Pārējie valodas LISP līdzekļi, tādi kā:– jaunu funkciju noteikšana– nosacījuma un beznosacījuma vadības

nodošana u.t.t.– tiek noteikti ar speciālu funkciju

palīdzību




• Funkcija QUOTE– Funkcija QUOTE ir vienīgā, kura

neatbilst noteikumam, ka pirmais saraksta elements ir funkcijas vārds, bet pārējie saraksta elementi ir tās funkcijas argumenti

– (QUOTE(saraksts)) vērtība ir pats saraksts




• (SETQ X (1 2 3)) ir bezjēdzīga– nozīmē: "mainīgajam x piešķirt funkcijas 1

vērtību ar argumentiem 2 un 3

• (SETQ X (QUOTE (1 2 3)))– mainīgajam X ir piešķirta saraksta vērtība– saīsināti (SETQ X ‘(1 2 3))

• funkcijas LIST vērtība ir tās argumentu saraksts– (LIST 1 2 3) vērtība ir (1 2 3)




• Ja mainīgajam x ir piešķirta vērtība 2– (LIST 1 x 3 x) vērtība ir (1 2 3 2)– (QUOTE(1 x 3 x)) vērtība ir (1 x 3 x)

• Par daudzu funkciju vērtību var būt saraksts– (DIVIDE 65 3) vērtība ir (21 2), kur

•21 - veselā daļa un 2 - dalījuma atlikums




• Ja par funkcijas argumentu jābūt atomam un šī argumenta vietā ir saraksts kaut arī no viena elementa, tas noved pie kļūdas. Piemēram,– (SETQ X (LIST 3))– (SETQ Y (PLUS X 1)) – kļūda, jo

mainīgajam X būs vērtība (3)




• Apakšsaraksts - saraksts, kurš ietverts citā sarakstā

• ((1 6)7((8 4)3))– (1 6)– 7– ((8 4)3)

•(8 4) •3



RekursijaRekursija

• Griežas pašas pie sevis– tieši vai arī netieši– griežas pati pie sevis – tieši– A griežas pie B un B pie A – netieši

•Vispārīgā gadījumā ķēdīte var būt garāka

– n! = n * (n-1)!•Pilnīgs noteikums 0! = 1

– izteiksme ir atoms vai (izteiksmju secība)



Funkciju izveidošana (1)Funkciju izveidošana (1)

• Parasti funkciju aprakstā ir četras pamatdaļas:– apraksta sākuma pazīme (vārds

FUNCTION, PROCEDURE u.t.t.)– funkcijas vārds– parametru saraksts pēc kārtas– nākošie teikumi, kuri patiesība

nosaka (definē) funkciju




• Valodā LISP– DEFUN - funkcija, lai aprakstītu funkciju

•3 argumenti– (DEFUN A (B C) D)

•D ir funkcijas A ar argumentiem B un C apraksts

– (DEFUN A (X Y) (+ X Y))– (DEFUN P (X) (* X X))

•(P 7) rezultāts ir 49




• Parametri– formālie

•tiek lietoti funkcijas aprakstam•tikai identifikatori

– faktiskie•lai grieztos pie funkcijas•var būt izteiksmes




• F(x,y) = x*x-y*y• (DEFUN F (X Y) (-(* X X) (* Y Y)))

– X un Y - formālie parametri– 4 un 3 – faktiskie parametri– (F 4 3) nozīmē, ka

• X saistās ar 4• Y saistās ar 3• F(4,3) =4*4-3*3=16-9=7




• (DEFUN F (X) (- (* X X) (* Y Y)))– funkcijas vērtība ir atkarīga no tā,

kāda vērtība funkcijas izskaitļošanas brīdī būs mainīgajam Y

– X ir saistošs (lokālais) mainīgais– Y ir brīvais (globālais) mainīgais



Funkcijas sarakstu apstrādei (1)Funkcijas sarakstu apstrādei (1)

• Trīs primitīvākās – CAR, CDR un CONS

• CAR– arguments ir saraksts– vērtība ir pirmais saraksta elements– Ja x ir (2 6 4 7), tad (CAR x) ir 2– Ja x ir (2 (6 (4 (7)))), tad (CAR x) ir 2– Ja x ir ((2 6)(4 7)), tad (CAR x) ir (2 6)




• CAR– Ja x ir ((((2)6)4)7), tad (CAR x) ir (((2)6)4)– Ja x ir atoms, tad (CAR x) novedīs pie

kļūdas– (CAR (1 2 3)) ir bezjēdzīga

• griešanos pie funkcijas 1 no argumentiem 2 un 3

– (CAR (QUOTE (1 2 3))) vērtība ir 1




• CDR– arguments ir saraksts– vērtība ir saraksta atlikums bez pirma

elementa– Ja x ir (2 6 4 7), tad (CDR x) ir (6 4 7)– Ja x ir ((2 6)(4 7)), tad (CDR x) ir ((4 7))– Ja x ir ((((2) 6) 4) 7), tad (CDR x) ir (7)




• CDR– Ja x ir saraksts ar precīzi vienu elementu,

tad (CDR x) ir NIL, kurš šajā gadījumā apzīmē tukšu sarakstu

– Ja x ir atoms, tad (CDR x) novedīs pie kļūdas




•CONS– savāc (savieno) to, ko CAR un CDR ir

sadalījusi daļās– pirmais arguments vienalga kas– otrais arguments obligāti saraksts– Ja x ir 2 un y ir (6 4 7), tad (CONS

x y) ir (2 6 4 7)




• CONS– Ja x ir 2 un y ir ((6 (4(7)))), tad (CONS x

y) ir (2 (6 (4 (7))))– Ja x ir (2 6) un y ir ((4 7)), tad (CONS x

y) ir ((2 6)(4 7))– Ja x ir (((2) 6) 4) un y ir (7), tad (CONS x

y) ir ((((2) 6) 4) 7)– (CONS (CAR x) (CDR x)) ir x




•CAR un CDR kombinācijas– (CAR (CDR L)) – saraksta L otrais

elements•saīsināti (CADR L)

– (CAR (CDR (CDR L))) – saraksta L trešais elements•saīsināti (CADDR L)

– u.t.t.




• Atkarībā no realizācijas D D– C ... R A A

– (CDADDR Y) nozīmē (CDR (CAR (CDR (CDR Y))))




•APPEND– savieno savā starpā divus sarakstus– Ja X ir (1 2 3) un Y ir (4 5 6), tad

(APPEND X Y) ir (1 2 3 4 5 6)– (CONS X Y) būtu ((1 2 3) 4 5 6)



Predikāti (1)Predikāti (1)

• Funkcijas, kuru vērtība (rezultāts) var būt "patiesība" vai "meli“

• Valodā LISP predikātiem ir vērtība– T - patiess vai– NIL - nepatiess




• Funkcija ATOM– arguments ir atoms vai saraksts– ja atoms, tad funkcijas vērtība ir T,

pretējā gadījumā NIL– ja X ir 5, tad (ATOM X) ir T– ja X ir simbols, tad (ATOM X) ir T– ja X ir (1 2 3), tad (ATOM X) ir NIL




• Funkcija NULL– pārbauda vai tās argumenta vērtība nav

NIL– ja X ir 5, tad (NULL X) ir NIL– ja X ir (1 2 3), tad (NULL X) ir NIL– ja X ir NIL, tad (NULL X) ir T – ja X ir saraksts no viena elementa, tad

(NULL X) ir NIL, bet (NULL (CDR X)) ir T




• Funkcija EQUAL– pārbauda vai divu tās argumentu

vērtība ir vienāda– ja X ir (4 6 (8 3)) un Y ir ((4 6) 8 3),

tad (EQUAL X Y) ir NIL– ja X ir (+ 2 2) rezultāts un Y ir 4, tad

(EQUAL X Y) ir T




• Funkcija ZEROP– pārbauda vai tās arguments ir nulle– burts P nosaukumā nozīmē "predicate“– ja arguments ir nulle, tad funkcijas vērtība ir

T, pretējā gadījumā - NIL.

• Funkcija GREATERP vai >– divi argumenti

• Citas funkcijas >= < <= <> u.t.t.



Nosacījuma izteiksmes (1)Nosacījuma izteiksmes (1)

• Nosacījuma operatora vietā, kā parasti, ir nosacījuma funkcija

• Funkcija COND– dažos gadījumos varam izlasīt sākot

ar "ja"– (COND ((ZEROP S)(SETQ Y 12)))

•ja S ir nulle, tad piešķirt mainīgajam Y vērtību 12




•COND– nenoteikts argumentu skaits– katrs no argumentiem ir pāris

•saraksts no diviem elementiem– pirmais pāra elements ir nosacījums– otrais pāra elements ir lielums vai

darbība– (COND ((> A 65) 10) ((> A 21) 30)

(T 0))




• COND– nenoteikts argumentu skaits– katrs no argumentiem ir pāris

• saraksts no diviem elementiem

– pirmais pāra elements ir nosacījums– otrais pāra elements ir lielums vai darbība– (COND ((> A 65) 10) ((> A 21) 30) (T

0))• if A>65 then 10 else if A>21 then 30 else 0




• Vispārējā gadījumā– LISP pēc kārtas apskata katru pāri no

pirmā līdz pēdējam– ja nosacījuma vērtība nav T, tiek ņemts

nākošais pāris– ja nosacījuma vērtība ir T, tad LISP

apstājas šajā vietā un par rezultātu ņem dotā pāra otro elementu

– pārbaude ne uz T, bet uz ne NIL




• Vispārējā gadījumā– LISP pēc kārtas apskata katru pāri – ja nosacījuma vērtība ir NIL, tiek ņemts nākošais

pāris– ja nosacījuma vērtība kaut kas cits, bet ne NIL,

tad LISP apstājas šajā vietā un par rezultātu ņem dotā pāra otro elementu

– (COND ((CDR L) 2) (T 1)) vērtība būs 2, ja L ir saraksts no vairāk kā viena elementa

– Pēdējais pāris ar T nodrošina, ka nosacījuma izteiksmei vienmēr ir vērtība (else sastāvdaļa)



Rekursīvas funkcijas (1)Rekursīvas funkcijas (1)

• faktoriāla rekursīvais nosacījums:– 0! = 1;– n! = n*(n-1)!

• Algoritmiskā valodā:integer procedure fact(n);integer n;fact:=if n =0 then 1 else n x fact (n-1);end



Rekursīvas funkcijas (2)Rekursīvas funkcijas (2)

• Valodā LISP(DEFUN FACT (N) (COND ((ZEROP N) 1) (T (* N (FACT (- N

1)))) ))



Sarakstu rekursīvā apstrāde (1)Sarakstu rekursīvā apstrāde (1)

• Noteiksim funkciju ADD– saskaita visus saraksta elementus

• ja L ir (1 2 3 4 5), tad (ADD L) ir 15

(DEFUN ADD (L) (COND((NULL L) 0)(T (+ (CAR L)(ADD (CDR L))))) )



Sarakstu rekursīvā apstrāde (2)Sarakstu rekursīvā apstrāde (2)

• Līdzīgā veidā var noteikt funkciju MULT– saraksta skaitļu reizinājums

• ja L ir (1 2 3 4 5), tad (MULT L) ir 120

(DEFUN MULT (L) (COND((NULL L) 1)(T (* (CAR L)(MULT (CDR L))))) )



Apakšsaraksti un rekursija (1)Apakšsaraksti un rekursija (1)

• Funkcija ADD strādā nepareizi, ja saraksts L satur apakšsarakstus– funkcijas PLUS argumenti var būt

tikai atomi• Noteiksim funkciju ADD2

– saskaita visus saraksta un to apakšsarakstu elementus•ja L ir (1 (2 (3 4)) 5), tad (ADD2 L) ir 15



Apakšsaraksti un rekursija (2)Apakšsaraksti un rekursija (2)

(DEFUN ADD2 (L) (COND((NULL L) 0)((ATOM (CAR L)) (+ (CAR L) (ADD2 (CDR L))))(T (+ (ADD2 (CAR L)) (ADD2 (CDR

L))))) )(ADD2 ‘(3 ((8 4) 7 (5 6))))



IzvadeIzvade

• Galarezultāts (visaugstākā līmeņa funkcijas rezultāts) ir izvests automātiski

• Starprezultāts– Funkcija PRINT– Neierobežots argumentu skaits– (PRINT 2 3 (+ 2 3))

2 3 5



Ievade (1)Ievade (1)

• Funkcija INPUT– bez argumentiem– vērtība ir rinda līdz – (+ INPUT() INPUT() )>2>35>



Ievade (2)Ievade (2)

• Funkcija INPUT>(CAR INPUT() )>(2 3)Error!>(CAR INPUT() )>’(2 3)2>



Rekursīvie predikāti (1)Rekursīvie predikāti (1)

• COND– pāru otrais elements

• T vai NIL

• Funkcija MEMBER – divi argumenti:

• atoms X• saraksts L

– ja X ir L sastāvdaļa, tad (MEMBER X L) ir T, pretējā gadījumā NIL



Rekursīvie predikāti (2)Rekursīvie predikāti (2)

(DEFUN MEMBER (X L) (COND((NULL L) NIL)((EQUAL X (CAR L) T)(T (MEMBER X (CDR L))) ))

(MEMBER ? ?)



Loģiskie operatori (1)Loģiskie operatori (1)

• “Loģiskais UN" (konjunkcija)• “Loģiskais VAI" (disjunkcija)• Noliegums (inversija)• Funkcija NOT

– viens arguments– vērtība ir T, ja par argumentu kalpo NIL, un

NIL, ja par argumentu kalpo kaut kas atšķirīgs no NIL• Faktiski tā dara to pašu, ko funkcija NULL




• Funkcija AND– nenoteikts argumentu skaits– vērtība vienmēr būs NIL, ja kaut viens arguments

vienāds ar NIL– pretējā gadījumā vērtība būs T

• Funkcija OR– nenoteikts argumentu skaits– vērtība vienmēr būs T, ja kaut viens arguments

nav vienāds ar NIL– pretējā gadījumā vērtība būs NIL




• Noteiksim funkciju MEM2– saistīta ar MEMBER tieši tāpat, kā

ADD2 ar ADD– pārbaudīs

•vai pirmais arguments nav kāda saraksta loceklis

•vai kāda tā apakšsaraksta loceklis•vai kāda tā apakšsaraksta apakšsaraksta

loceklis•un tā tālāk




(DEFUN MEM2 (X L) (COND ((NULL L) NIL) (T (OR (COND ((ATOM (CAR L))

(EQUAL X (CAR L)))

(T (MEM2 X (CAR L))) ) (MEM2 X (CDR L))) ) )



Rekursīvās funkcijasRekursīvās funkcijasno diviem sarakstiem (1)no diviem sarakstiem (1)

• Kā tiek noteikta funkcija APPEND– apvieno divus sarakstus(DEFUN APPEND (L M) (COND((NULL L) M)(T (CONS (CAR L) (APPEND (CDR L)

M ) ))) )

(APPEND L M ) ja L ir (1 2 3) un M ir (4 5 6)




• Noteiksim funkciju EQUAL– argumenti var būt saraksti ar

apakšsarakstiem – ar funkcijas EQ palīdzību

• argumenti tikai atomi

– saraksti L un M ir vienādi, ja• vienādi ir to pirmie elementi (CAR L) un (CAR M)• un vienādas arī atlikušās sarakstu daļas (CDR L)

un (CDR M)• jābūt vienādiem abiem šiem pāriem




(DEFUN EQUAL (L M) (COND((NULL L) NULL M))((ATOM L) (AND (ATOM M) (EQ L M)))((ATOM M) NIL)(T (AND (EQUAL (CAR L) (CAR M)) (EQUAL (CDR L) (CDR M))) )) )



Funkcijas tipu izzināšanai (1)Funkcijas tipu izzināšanai (1)

• Predikāts NUMBERP– viens arguments– predikāta vērtība ir T, ja argumentam ir

skaitliska vērtība– ja X ir 5, tad (NUMBERP X) ir T– ja X ir simboli ABC, tad (NUMBERP X) ir

NIL– ja X ir (1 2 3), tad (NUMBERP X) ir NIL




• Funkcijas FIXP un FLOATP– viens arguments– FIXP vērtība ir T, ja arguments ir skaitlis ar

fiksētu punktu– FLOATP vērtība ir T, ja arguments ir

skaitlis ar peldošu punktu– ja X ir 7, tad (FIXP X) ir T, bet (FLOATP

X) ir NIL– ja X ir 7.5, tad (FIXP X) ir NIL, bet

(FLOATP X) ir T




• Noteiksim funkciju COUNTFIXFLOAT– funkcijas arguments ir saraksts L– funkcijas vērtība būs saraksts no diviem

elementiem• pirmais elements – ciparu skaits formā ar

fiksētu punktu• otrais - ciparu skaits ar peldošu punktu

– ja X ir (T LAM 5.6 3(8((9.1 4.122 J)B 6 3.1 R)), tad

– (COUNTFIXFLOAT X) ir (3 4)




(DEFUN COUNTFIXFLOAT (L) (COND((NULL L) (QUOTE (0 0)))((ATOM L) (COND ((FIXP L) (QUOTE (1 0))) ((FLOATP L) (QUOTE (0

1))) (T (QUOTE (0 0))) )(T (SUM2 (COUNTFIXFLOAT (CAR L)) (COUNTFIXFLOAT (CDR L))) ) ))




(DEFUN SUM2 (L M)(CONS (+ (CAR L) (CAR M)) (LIST (+ (CADR L) (CADR M)))))

ja X ir (4 3), bet Y ir (7 2), tad(SUM2 X Y) ir (11 5)



PROG-izteiksmes (1)PROG-izteiksmes (1)

• Secīgu operatoru veids• Pārveido funkcionālo pierakstu uz

nefunkcionālo pierakstu– realizē algoritmiskās valodās jēdzienus:

• apraksti• operatori• iezīmes• vadības nodošana• nosacījuma izteiksmes• vērtību atgriešana




• Apraksti– pirmais funkcijas PROG arguments

• mainīgo saraksts, kuri tiks izmantoti dotajā PROG

– parametri netiek ieslēgti šajā sarakstā– mainīgā tips netiek noteikts

• atkarīgs no piešķirtas vērtības

– mainīgo vērtībām jābūt noteiktām, līdz to lietošanas momentam

– mainīgie var būt saraksti• var izmantot masīvu vietā




• Operatori– piešķirta PROG argumentu loma– SETQ un SET tipa izteiksmes

• Iezīmes– piešķirta PROG argumentu loma– vienmēr atsevišķs atoms

•atšķiras no griešanās pie funkcijām




• Ir trīs tipu PROG argumenti:– pirmais arguments

•PROG-mainīgo saraksts

– operatori•lai grieztos pie funkcijām

– Iezīmes

• Argumentu skaits ir neierobežots




• Vadības nodošana– operators GO– vienīgais arguments ir iezīme– (GO SIGMA)

•nozīmē vadības nodošanu uz iezīmi SIGMA

•operatoram, kurš seko tūlīt pēc šīs iezīmes




• Nosacījuma izteiksmes– funkcija COND– divas atšķirības no izmantošanas funkcijās

• pāra otrais elements nav lielums, bet ir operators– jebkura tipa

• pēdējam pārim nav obligāti jāsākas ar T– Tas ir analoģiski operatoram IF-THEN bez ELSE daļas

• Vērtības atgriešana– funkcija RETURN– viens arguments– PROG-izteiksmes vērtība



FaktoriālsFaktoriāls

• Variants algoritmiska valodā:INTEGER FUNCTION FACT(N)I=NJ=1

1 IF (I .EQ. 0) GOTO 2J=J*II=I-1GOTO 1

2 FACT=JRETURNEND



PROG-faktoriālsPROG-faktoriāls

• Variants valodā LISP:(DEFUN FACT (N) (PROG (I J)(SETQ I N) (SET J 1)K (COND ((ZEROP I) (GO L)))(SETQ J (* J I))(SETQ I (- I 1))(GO K)L (RETURN J) ))



PROG. Sarakstu apstrāde (1)PROG. Sarakstu apstrāde (1)

• Tas nav saraksts, bet gan drīzāk viendimensijas masīvs

• Indekss– mainās ar vieninieku, lai pārietu uz nākošo

masīva elementu• funkcija CDR izsvītro pirmo saraksta elementu

– algoritmiskā valodā:S=0DO 1 I=1,100

1 S=S+A(I)



PROG. Sarakstu apstrāde (2)PROG. Sarakstu apstrāde (2)

• Pārrakstīsim funkciju ADD, izmantojot PROG-izteiksmes

(DEFUN ADD (L) (PROG (M N)(SETQ M L) (SETQ N 0)A (COND ((NULL M) (RETURN N)))(SETQ N (+ N (CAR M)))(SETQ M (CDR M)) (GO A) ))• Nav tik efektīva un “caurspīdīga” kā

rekursīvā



PROG. Sarakstu veidošana (1)PROG. Sarakstu veidošana (1)

• Pats efektīvākais saraksta apstrādes veids– apstrāde no sākuma– CAR un CDR

• Veidot sarakstu visefektīvāk no beigām– pēdējo elementu jāizskaitļo pirmo– jauni elementi jāpievieno saraksta sākumā– pirmo saraksta elementu jāizskaitļo pēdējo– CONS




• Noteiksim programmu REVERSE– pārraksta sarakstu apgrieztā kartībā

(DEFUN REVERSE (L) (PROG (M P)(SETQ M L) (SETQ P NIL)A(COND (( NULL M) (RETURN P)))(SETQ P (CONS (CAR M) P))(SETQ M (CDR M)) (GO A) ))




• Izveidošana it kā no sākuma• Noteiksim funkciju DOUBLE

– dubulto katru veselu skaitli no veselu skaitļu saraksta

(DEFUN DOUBLE (X) (COND ((NULL X) X)(T (CONS (+ (CAR X)(CAR X))

(DOUBLE (CDR X))) ) ) )



Funkcijas darbība (1)Funkcijas darbība (1)

• Divdimensiju masīvs - sarakstu saraksts– vieninieku matrica δij NxN,

•δij = 1, ja i=j un•δij = 0, ja i nav = j,•kur 1<= i, j <=N

– N=4 • ( (1 0 0 0) (0 1 0 0) (0 0 1 0) (0 0 0

1) )




• Noteiksim funkciju UNITMATR– (UNITMATR N) rezultāts ir vieninieku

masīvs NxN(DEFUN UNITMATR (N) (PROG (I J K L

Z)I - matricas rindas kārtas numursJ - matricas stabiņa kārtas numursK - saraksts, kurš atbilst tekošai rindaiL - rezultējošā matricaZ - tekošais matricas rindas elements




(SETQ I N) (SETQ L NIL)A (SETQ J N) (SETQ K NIL)B (COND ((EQUAL I J)(SETQ Z 1))

(T (SETQ Z 0)) )(SETQ K (CONS Z K)) (SETQ J (- J 1))(COND ((> J 0)(GO B)))(SETQ L (CONS K L) (SETQ I (- I 1))(COND ((> I 0)(GO A)))(RETURN L) ))



Programmas saīsināšanaProgrammas saīsināšana

• Izmantot funkciju vienlaicīgi gan darbību izpildei, gan vērtības iegūšanai– nomainīt divus operatorus

(SETQ J (- J 1)) (COND ((> J 0) (GO B)))

– uz vienu operatoru(COND ((> (SETQ J (- J 1)) 0) (GO B)))• atņemt 1 no vērtības J• iegūt jaunu J vērtību• pārbaudīt jaunu J vērtību



PROG. Predikāti (1)PROG. Predikāti (1)

• Jāatgriež T vienā vietā un NIL citā– pie kam var būt vairāki RETURN operatori

vienā PROG- izteiksmē• Piemērs

– Predikāta arguments ir saraksts, kurš attēlo spēļu kārtis

– Katra kārts tiek attēlota ar sarakstu, sastāvošu no diviem elementiem• masts• lielums• (Pīķa dūzis) (Kārava 10) (Kreiča 5)




• Noteiksim funkciju PIKUNAV(DEFUN PIKUNAV (L) (PROG (M P)

(SETQ M L)A (COND ((NULL M) (RETURN T))) (SETQ P (CAR M)) (SETQ M (CDR

M)) (COND ((EQUAL (CAR P) ‘Pīķa)

(RETURN NIL))) (GO A) ))



RekursijaRekursija

• PIKUNAV funkcionālā veida(DEFUN PIKUNAV (L) (COND((NULL L) T)(T (AND (NOT (EQUAL (CAAR L) ‘Pīķa)) (PIKUNAV (CDR L))) )) )




(DEFUN ERCENU_VAIRĀK_KĀ_PĪKU (L) (PROG ( M P X Y) ;X,Y - ercenu pīķu skaits

(SETQ M L) (SETQ X 0) (SETQ Y 0)A (COND ((NULL M) (RETURN (> X Y))))

(SETQ P (CAR M)) (SETQ M (CDR M))(COND ((EQUAL (CAR P) ‘Ercena)

(SETQ X (+ X 1)) ) ((EQUAL (CAR P) ‘Pīķa )

(SETQ Y (+ Y 1)) ) )(GO A) ))



RekursijaRekursija

• Funkcionālā veida(DEFUN ERCENU_VAIRĀK_KĀ_PĪKU (L)(> (PIKI L) (ERCENI L)) )(DEFUN PIKI (L) (COND((NULL L) 0)((EQUAL (CAAR L) ‘Pīķa) (+ 1 (PIKI

(CDR L))))(T(PIKI (CDR L))) ))(DEFUN ERCENI (L) ...



Rekursija PROG-izteiksmēsRekursija PROG-izteiksmēs

• Apakšsarakstu apstrāde(DEFUN ADD2 (L) (PROG (M N X)

(SETQ M L) (SETQ N 0)A (COND ((NULL M) (RETURN N)))

(SETQ X (CAR M)) (SETQ M (CDR M))(COND ((ATOM X) (SETQ N (+ N X)))

(T (SETQ N (+ N (ADD2 X)))))

(GO A) ))



SaīsināšanaSaīsināšana

• Iepriekšējais variants(COND ((ATOM X) (SETQ N (+ N

X)))(T (SETQ N (+ N (ADD2

X)))))

• Īsāk(SETQ N (+ N (COND ((ATOM X) X)

(T (ADD2 X)) )))



Apakšsarakstu apstrādeApakšsarakstu apstrāde

• Noteiksim funkciju ADD3– arguments ir apakšsarakstu saraksts– vērtība - katra apakšsaraksta elementu

summa atsevišķi– ja X ir ((2 4)(3 1)(6 2)), tad (ADD3 X) ir

(6 4 8)

(DEFUN ADD3 (L) (COND (( NULL L) NIL)(CONS (ADD2 (CAR L)) (ADD3 (CDR

L))) ))



Funkciju apvienošana (1)Funkciju apvienošana (1)

(COND ((ZEROP K) (PROG NIL (SETQ Y X) (SETQ Z X)) ))

(COND ((ZEROP K) (PROGN (SETQ Y X) (SETQ Z X)) ))

K=0

Y = X

Z = X

jā

nē




• Noteiksim funkciju OPPMAX– argumenti

• skaitļu saraksts L• simbolu saraksts M

– vērtība - saraksta M elements, kurš pēc sava stāvokļa atbilst maksimālajam elementam no saraksta L

– ja L ir (3 7 13 9) un M ir (T E S T), tad (OPPMAX L M) ir S




(DEFUN OPPMAX (L M) (PROG (A B U V Y Z)

A - kandidāts uz maksimālo elementusākotnēji saraksta L pirmais elements

B - atbilstošais sarakstā M elementssākotnēji arī pirmais

Ja tiek atrasts elements, kurš ir lielāks par A, tad jaunu vērtību iegūst gan A gan B




(SETQ A (CAR L)) (SETQ B (CAR M))(SETQ U (CDR L)) (SETQ V (CDR M))

G (COND ((NULL U) (RETURN B)))(SETQ Y (CAR U)) (SETQ Z (CAR V))(SETQ U (CDR U)) (SETQ V (CDR V))(COND ((> Y A)

(PROGN (SETQ A Y)(SETQ B Z)) ))(GO G) ))



Izskaitļošanas noteikums (1)Izskaitļošanas noteikums (1)

(SETQ Z 3)(SETQ Y (+ Z (SETQ Z 6)));y=3+6=9(SETQ Y (+ (SETQ Z 6) Z)))

;y=6+6=12• Funkcijas izskaitļošanas noteikums

– lai izskaitļotu funkciju, tās argumenti gan atomi, gan griešanas pie funkcijām, tiek izskaitļoti pēc kārtas no kreisās uz labo

– pēc tam funkcijas definīcija tiek pielietota šim vērtību sarakstam




• AND un OR izskaitļotas citādā veidā– (AND X Y ...)

• vērtība ir ne NIL, ja visi argumenti ir ne NIL• ja X ir NIL, tad (AND X Y) vērtībai ir jābūt

NIL• nav nepieciešams izskaitļot Y• tas ne tikai saīsina laiku, bet arī aizsargā no

kļūdu rašanās• (AND (ATOM M)(EQ L M)) ; pareizi• (AND (EQ L M) (ATOM M)) ; kļūdaini




–(OR X Y ...)•vērtība ir ne NIL, ja ik viens arguments ir ne NIL

•ja X ir ne NIL, tad (OR X Y) vērtībai ir jābūt ne NIL

•nav nepieciešams izskaitļot Y•saīsina laiku



Izskaitļojoša funkcija (1)Izskaitļojoša funkcija (1)

• Ja ir mainīgais, kura vērtība ir saraksts• Ja saraksts var saprast, ka griešanās

pie funkcijas– par pirmo elementu kalpo funkcijas vārds– citi elementi ir tās funkcijas argumenti

• Lai atrastu šīs funkcijas vērtību, jālieto funkciju EVAL

• Ja X ir (+ 2 3), tad (EVAL X) ir 5




• Ar EVAL palīdzību var izpildīt operatoru– kuru ir izveidojusi paša LISP- programma– kurš var mainīties programmas izpildes

procesā

• Noteikt funkciju– mainīgais NAME – funkcijas nosaukums– mainīgais PARAMETERLIST - šīs funkcijas

parametru saraksts– mainīgais DESCRIPTION – šis funkcijas apraksts




(EVAL (LIST ‘DEFUN NAME PARAMETERLIST

DESCRIPTION ))• Funkcija LIST izveido sarakstu formā (DEFUN

n p d), – kur n, p un d – ir mainīgajos NAME,

PARAMETERLIST un DESCRIPTION atbilstošā vērtība

• Pēc tam šis saraksts tiek izskaitļots – tiks definēta jauna funkcija




• Ja NAME ir simbolu rinda “DIFFERENCE”

• ja PARAMETERLIST ir (X Y) - ir saraksts no burtiem X un Y

• ja DESCRIPTION ir saraksts (PLUS X (MINUS Y))

• tad augstāk minētā EVAL izpilde kalpos funkcijas DIFFERENCE noteikšanai



Programma kā dati (1)Programma kā dati (1)

• Programma ir sarakstu struktūra• Izmantosim mainīgos, kuru vērtības būs

programmas dažādas sastāvdaļas• Izskatīsim funkciju

(FOR I J K L DESCR)– kura atbilst operatoram

for I:=J step K until L do DESCR;




• Funkcijas (FOR I J K L DESCR) vērtībai jābūt :

( ( SETQ I J)B (COND ((> I L) (GO A)))

descr (SETQ I (+ I K)) (GO B)

A )kur descr – mainīgā DESCR vērtība

• Būtiska problēma - iezīmes B un A




• Iezīmes B un A problēma– nav iespējams garantēt, ka simboli B un A netiks

izmantoti kā iezīmes programmas daļā, kuru ietver DESCR

– Ir iespējams izsaukt FOR vairākas reizes vienā programmā

– tas novedīs pie atkārtoti noteiktām iezīmēm– šī problēma tiek risināta ar valoda LISP funkcijas

GENSYM• funkcija bez argumentiem• ģenerē atomus, kuri atšķiras no atomiem, kuri

tika iegūti ar tās palīdzību agrāk




(DEFUN FOR (I J K L D) (PROG (W X Y Z)(SETQ X (APPEND D (LIST (LIST ‘SETQ I

(LIST ‘+ I K)))))

(SETQ Y (GENSYM)) (SETQ Z (GENSYM))(SETQ X (APPEND X (LIST (LIST ‘GO Y) Z) ))(SETQ W (LIST (LIST ‘SETQ I J)

Y (LIST ‘COND (LIST (LIST ‘> I L) (LIST ‘GO Z )))))

(RETURN (APPEND W X)) ))

;W - veidojamās programmas pirmā daļa, X – otrā daļa




• Funkcijas (FOR ‘N 1 2 100 ‘((PRINT N))) rezultāts(SETQ X (APPEND D

(LIST (LIST ‘SETQ I (LIST ‘+

I K) ) ) ) ) X iegūs vērtību((PRINT N) (SETQ N (+ N 2 )))




• Funkcijas (FOR ‘N 1 2 100 ‘((PRINT N))) rezultāts

(SETQ Y (GENSYM))(SETQ Z (GENSYM))Y iegūs vērtību “Gen1”Z iegūs vērtību “Gen2”




• Funkcijas (FOR ‘N 1 2 100 ‘((PRINT N))) rezultāts

(SETQ X (APPEND X (LIST (LIST ‘GO Y) Z)

) )X iegūs vērtību((PRINT N) (SETQ N (+ N 2 )) (GO

Gen1) Gen2)




• Funkcijas (FOR ‘N 1 2 100 ‘((PRINT N))) rezultāts(SETQ W (LIST (LIST ‘SETQ I J)

Y (LIST ‘COND (LIST (LIST ‘> I L) (LIST ‘GO Z )

) ) ) )W iegūs vērtību( (SETQ N 1) Gen1 (COND ((> N 100)(GO Gen2))) )




• Funkcijas (FOR ‘N 1 2 100 ‘((PRINT N))) rezultāts(RETURN (APPEND W X))Funkcija FOR iegūs vērtību

( (SETQ N 1)Gen1 (COND ((> N 100) (GO Gen2)))

(PRINT N) (SETQ N (+ N 2 )) (GO Gen1 )

Gen2)




• Funkcijas FOR rezultāts ir saraksta veida struktūra, kas atbilst programmai

• Lai izpildītu šo programmu, jāgriežas pie funkcijas EVAL

(EVAL (FOR ‘N 1 2 100 ‘((PRINT N))) )

Documents

Funkcionālā programmēšana (DIP330)