Čtení ze souboru
Vstup/výstup, databázové operace, rozklad termu
Predikáty pro vstup a výstup
I ?- read(A), read( ahoj(B) ), read( [C,D] ).
|: ahoj. ahoj( petre ).  [ ahoj( 'Petre!' ), jdeme ].
A = ahoj, B = petre, C = ahoj('Petre!'), D = jdeme
I ?- write(a(l)), write('.'), nl, write(a(2)), write('.'), nl
a(l).
a(2).
yes
■ seeing, see, seen, read
■ telling, tell, told, write
■ standardní vstupní a výstupní stream: user
Hana Rudová, Logické programování I, 21. dubna 2010
Vstup/výstup, databázové operace, rozklad termu
process_file( Soubor ) :-
seeing( StarySoubor ), see( Soubor ), repeat,
read( Term ), process_term( Term ) , Term == end_of_file,
% zjištěni aktivniho proudu % otevřeni souboru Soubor
% čteni termu Term % manipulace s termem % je konec souboru?
seen,
see( StarySoubor ).
% uzavřeni souboru
% aktivace původniho proudu
repeat. repeat
repeat.
% vestavěný predikát
Hana Rudová, Logické programování 1,21. dubna 201 0
Vstup/výstup, databázové operace, rozklad termu
Příklad: vstup/výstup
Napište predikát uloz_do_souboru( Soubor ), který načte několik fakt ze vstupu a uloží je do souboru Soubor.
| ?- uloz_do_souboru( 'soubor.pl ' ).
faktCmirek, 18). fakt(pavel,4).
yes
| ?- consult(soubor).
% Consulting /home/hanka/soubor.pl...
% consulted /home/hanka/soubor.pl in module user, 0 msec
% 376 bytes
yes
I ?- 1 istingCfakt/2) . % pozor:listing/1 lze použít pouze při consult/1 (ne u compile/1) fakt(mi rek, 18). faktCpavel, 4). yes
Hana Rudová, Logické programování 1,21. dubna 201 0
Vstup/výstup, databázové operace, rozklad termu
Implementace: vstup/výstup
uloz_do_souboru( Soubor ) :-seeingC StaryVstup ), tellingC StaryVystup ), see( user ), tel 1 C Soubor ), repeat,
read( Term ),
process_term( Term ),
Term == end_of_file,
i
seen, told,
tellC StaryVystup ), see( StaryVstup ).
process_term(end_of_file) :- !. process_term( Term ) :-
writeC Term ), writeC'.'), nl.
Hana Rudová, Logické programování I, 21. dubna 2010 5 Vstup/výstup, databázové operace, rozklad termu
Databázové operace
■ Databáze: specifikace množiny relací
■ Prologovský program: programová databáze, kde jsou relace specifikovány
explicitně (fakty) i implicitně (pravidly)
■ Vestavěné predikáty pro změnu databáze během provádění programu:
assert( Klauzule ) přidání  Klauzule do programu
asserta( Klauzule ) přidání na začátek
assertz( Klauzule ) přidání na konec
retract( Klauzule ) smazání klauzule unifikovatelné s Klauzule
■ Pozor: retract/1 lze použít pouze pro dynamické klauzule (přidané pomocí assert) a ne pro statické klauzule z programu
■ Pozor: nadměrné použití těchto operací snižuje srozumitelnost programu
Hana Rudová, Logické programování 1,21. dubna 201 0 6 Vstup/výstup, databázové operace, rozklad termu
Databázové operace: příklad
Napište predikát vytvor_program/0, který načte několik klauzulí ze vstupu a uloží je do programové databáze.
| ?- vytvor_program.
|: faktCpavel, 4).
|: pravidlo(X.Y) :- fakt(X.Y).
I :
yes
| ?- 1 isting(fakt/2). faktCpavel, 4). yes
| ?- listingCpravidlo/2). pravidlo(A, B) :- fakt(A, B). yes
| ?- clauseC pravidloCA, B) , C) . % clause/2 použitelný pouze pro dynamické klauzule
C = fakt(A.B) ?
yes
Hana Rudová, Logické programování I, 21. dubna 2010 7 Vstup/výstup, databázové operace, rozklad termu
Databázové operace: implementace
vytvo r_p rog ram :-
seeingC StaryVstup ), see( user ) , repeat,
read( Term ),
uloz_term( Term ),
Term == end_of_file,
i
seen,
see( StaryVstup ).
uloz_term( end_of_file ) :- !. uloz_term( Term ) :-
assertC Term ).
Hana Rudová, Logické programování 1,21. dubna 201 0 8 Vstup/výstup, databázové operace, rozklad termu
Konstrukce a dekompozice termu
Konstrukce a dekompozice termu
Term =..  [ Funktor | SeznamArgumentu ]
a(9,e) =.. [a,9,e]
Cil =..  [ Funktor | SeznamArgumentu ], call( Cil ) atom =. . X => X = [atom]
Pokud chci znát pouze funktor nebo některé argumenty, pak je efektivnější:
functor( Term, Funktor, Arita ) functorC a(9,e), a, 2 )
functor(atom,atom,0)      functor(l,1,0) arg( N, Term, Argument ) argC 2, a(9,e), e)
Hana Rudová, Logické programování I, 21. dubna 2010
Vstup/výstup, databázové operace, rozklad termu
Rekurzivní rozklad termu
Term je proměnná (var/l), atom nebo číslo (atomic/1) => konec rozkladu
Term je seznam ([_|_]) =>
procházení seznamu a rozklad každého prvku seznamu
Term je složený (=../2 , functor/3) =>
procházení seznamu argumentů a rozklad každého argumentu
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
ground(Term) :- atomic(Term), !. % Term je atom nebo čislo NEBO
ground(Term) :- var(Term),  !, fail. % Term neni proměnná NEBO
groundC[H|T]) :- !, ground(H), ground(T). % Term je seznam a ani hlava ani těl
% neobsahuji proměnné NEBO
ground(Term) :- Term =..  [ _Funktor | Argumenty ], % je Term složený groundC Argumenty ). % a jeho argumenty
% neobsahuji proměnné
?- ground(s(2,[a(l,3),b,c],X)). ?- ground(s(2,[a(l,3),b,c])).
yes
Hana Rudová, Logické programování 1,21. dubna 201 0
Vstup/výstup, databázové operace, rozklad termu
subterm(S,T)
Napište predikát subterm(S,T) pro termy S aT bez proměnných, které uspějí, pokud je S podtermem termu T. Tj. musí platit alespoň jedno z
■ podterm S je právě term T NEBO
■ podterm S se nachází v hlavě seznamu T NEBO
■ podterm S se nachází v těle seznamu T NEBO
■ T je složený term (compound/1), není seznam (T\=[_|_]), a S je podtermem některého argumentu T.
■ pokud nepoužijeme 0~\=[_|_]), pak dotaz :- subterm(a, [1]) . cyklí!
■ pokud nepoužijeme (compound/1), pak dotaz :- subterm(l,2) . cyklí!
| ?- subterm(sin(3),b(c,2,[l,b],sin(3) ,a)) . yes subterm(T.T) :- !.
subtermCS,[H|_]) :- subterm(S,H), !. subtermCS,[_|T]) :- subtermCS,T),!.
subtermCS,T) :- compoundCT), T\=[_|_], T=..[_|Argumenty], subtermCS.Argumenty).
Hana Rudová, Logické programování I,21.dubna2010 11 Vstup/výstup, databázové operace, rozklad termu
same(A,B)
Napište predikát same(A, B), který uspěje, pokud mají termy A a B stejnou strukturu. Tj. musí platit právě jedno z
■ A i B jsou proměnné NEBO
■ pokud je jeden z argumentů proměnná (druhý ne), pak predikát neuspěje, NEBO
■ A i B jsou atomic a unifikovatelné NEBO
■ A i B jsou seznamy, pak jak jejich hlava tak jejich tělo mají stejnou strukturu NEBO
■ A i B jsou složené termy se stejným funktorem a jejich argumenty mají stejnou strukturu
| ?- sameC[l,3,sinCX),sCa,3)],[l,3,sinCX),sCa,3)]). yes
sameCA.B) :- varCA), varCB), !.
sameCA.B) :- varCA),  !, fail.
sameCA.B) :- varCB),  !, fail.
sameCA.B) :- atomicCA), atomicCB),  !, A==B.
same C[HA|TA],[HB|TB]) :- !, sameCHA,HB), sameCTA.TB).
sameCA.B)  :- A=..[FA|ArgA], B=..[FB|ArgB], FA==FB, sameCArgA,ArgB).
Hana Rudová, Logické programování 1,21. dubna 201 0 1 2 Vstup/výstup, databázové operace, rozklad termu
D.Ú. unify(A,B)
not_occurs(A,B)
Napište predikát uni fy(A, B), který unifikuje termy A a B a provede zároveň kontrolu výskytu.
| ?- unify([Y,3,sin(a(3)),s(a,3)],[1,3,sin(X),s(a,3)]). X = a(3)        Y = 1 yes
unify(A,B)  :- var(A), var(B),  !,   A=B.
unify(A,B)  :- var(A),   !, not_occurs(A,B), A=B.
unify(A,B)  :- var(B),   !, not_occurs(B,A), B=A.
unify(A,B)  :- atomic(A), atomic(B),   !, A==B.
unify([HA|TA],[HB|TB])  :- !, unify(HA,HB), unify(TA,TB).
unify(A,B)  :- A=..[FA|ArgA], B=..[FB|ArgB], FA==FB, unify(ArgA,ArgB)
Predikát not_occurs(A, B) uspěje, pokud se proměnná A nevyskytuje v termu B. Tj. platí jedno z
■ B je atom nebo číslo NEBO
■ B je proměnná různá od A NEBO
■ B je seznam a A se nevyskytuje ani v těle ani v hlavě NEBO
■ B je složený term a A se nevyskytuje v jeho argumentech
not_occurs(_,B)  :- atomic(B), !. not_occurs(A,B)  :- var(B),  !, A\==B.
not_occurs(A,[H|T])  :- !, not_occurs(A,H), not_occurs(A,T). not_occurs(A,B)  :- B=..[_|Arg], not_occurs(A,Arg).
Hana Rudová, Logické programování I, 21. dubna 2010
Vstup/výstup, databázové operace, rozklad termu
Hana Rudová, Logické programování 1,21. dubna 201 0
Vstup/výstup, databázové operace, rozklad termu