Prolog Dictionary

Aceasta versiune a dictionarului Prolog isi asuma sintaxa Prolog SWI. Cateva exemple si asuma un interpretor de comenzi Unix, la fel ca in Linux si MacOS X / Terminal.

Ar trebui sa folositi Dictionar Prolog sa se clarifice sau sa revizuiasca conceptele care le-ati cunoscut deja. Dictionar Prolog nu este o modalitate potrivita de a incepe sa invatati despre Prolog. Acestea fiind spuse, acest dictionar este conceput pentru a fi utilizat de catre programatori Prolog incepator si intermediar. Mai multe informatii despre Prolog pot fi gasite in documentatia SWI Prolog legate de mai sus.

Alte dictionare legate de:
Dictionar AI - URL: http://www.cse.unsw.edu.au/~billw/aidict.html
Dictionar Masina de invatare - URL: http://www.cse.unsw.edu.au/~billw/mldict.html
Dictionar NLP (procesarea limbajului natural) - URL: http://www.cse.unsw.edu.au/~billw/nlpdict.html

Alte locuri pentru a afla mai multe despre inteligenta artificiala includ AAAI (Asociatia Americana pentru Inteligenta Artificiala) AI Prezentare pagina sau de referinta Perioada de valabilitate AI

URL-ul acestui Dictionar Prolog este

Subiectele acoperite

Acest dictionar a fost limitat la conceptele acoperite in Prolog COMP9414 Inteligenta Artificiala de la Universitatea din New South Wales, Sydney. Acesta a fost ulterior extins pentru a acoperi conceptele Prolog in COMP9814 inteligenta artificiala, precum si extinderea. Oricum, aceasta nu acopera in prezent, anumite concepte care stau la baza Prolog (rezolutie, etc) De asemenea, nu acopera toate de ISO Prolog - Odata ce ati inteles totul in Dictionarul Prolog, ar trebui sa fie cu siguranta, gata sa se??scufunde in documentatia care vine cu tale favorite Prolog interpret.

Mai multe detalii despre Prolog pot fi gasite in notele de curs COMP9414 si COMP9814 notele de curs. Conceptele de baza Prolog - ca este, cele care fac obiectul / utilizate in COMP9414 - sunt marcate cu puncte verzi (•) in indicele de mai jos, si au, de asemenea, cuvant-titlu din articol despre ele in verde.

Index

Nu exista intrari (inca) pentru literele J, K, X, Y, Z.

append

Built-in predicat append(?List1,?List2,?List1_then_List2) reuseste daca List1, urmata de List2 = List1_then_List2. Exemple:

?- append([a, b], [c, d, e], Result).
Result = [a, b, c, d, e].
true.
?- append([a, b], SecondBit, [a, b, c, d, e]).
SecondBit = [c, d, e]
true.
?- append(FirstBit, [c, d, e], [a, b, c, d, e]).
FirstBit = [a, b]
true.

O greseala incepator nu mai putin frecvente este de a folosi append([Head], Tail, List) pentru a construi o lista in loc de ceva de genul List = [Head | Tail]. Acest lucru va functiona, dar este ca cu ajutorul unui buldozer pentru a sapa o groapa pentru a planta un rasad.

Nota: exista, de asemenea, o versiune independent de append care ia un singur parametru. Acest lucru este descris in conformitate cu fisiere, si este mentionata ca append/1 - adica 1 argument, in timp ce append in acest articol este mentionat ca append/3 - 3 argumente.

arg

Nu este un strigat de frustrare la inca un alt mesaj de eroare, ci, mai degraba, o abreviere pentru argument, si, de asemenea, numele a construit-o in predicat metalogical, care extrage argumente dintr-o structura. Exemplu:

?- arg(2, buys(john, beer), Arg).
Arg = beer

De asemenea, este posibil sa se puna argumentele in ceea ce priveste utilizarea arg, ar trebui acest lucru se dovedeste util:

?- X = likes(mary, Y), arg(2, X, pizza).
X = likes(mary, pizza)
Y = pizza

argument

A se vedea arg, termen.

aritmetica

Multe dintre operatorii aritmetici uzuale sunt disponibile in Prolog:

Operator	Semnificatie	Exemplu
+	plus	2 is 1 + 1.
-	scadere	1 is 2 – 1.
-	unar minus	Incercati interogarea X is 1, Y is - X.
*	multiplicare	4 is 2 * 2.
/	diviziune	2 is 6 / 3.
/ /	intreg diviziune	1 is 7 // 4.
Mod	intreg restul	3 is 7 mod 4.
**	exponentiation	1.21 is 1.1 ** 2.

Cu exceptia, in contextul unui operator de comparatie aritmetic, expresii aritmetice trebuie sa fie evaluate in mod explicit Prolog, folosind is built-in predicat.

In mare parte se foloseste acesti operatori intr-un gol mai mult ca aceasta:

X is Y + 2

in cazul in care Y este o variabila deja legat la o valoare numerica, sau poate un obiectiv compararea aritmetica ca aceasta:

X > Y * Z

Iata un alt exemplu: o regula pentru a spune daca un numar (intreg) este impar:

odd(Num) :- 1 is Num mod 2.

Un alt mod de a face aceasta este de a utiliza =:= :

odd(Num) :- Num mod 2 =:= 1.

Daca ati fi dorit sa fie mai precaut, ai putea verifica in primul rand ca Num este de fapt un numar intreg:

odd(Num) :- integer(Num), 1 is Num mod 2.

Ca de obicei in calculele digitale, cu numere fractionare, este necesar sa fie atent cu probleme de armonizare. Astfel, de exemplu finala in tabelul de mai sus, 1.21 is 1.1 ** 2. de fapt, nu reuseste atunci tastate in Prolog ca o interogare. Acest lucru se datoreaza faptului ca 1.1 ** 2, asa cum este reprezentat in computere, vine de fapt a fi ceva de genul 1.210000000001. A se vedea sectiunea privind operatorii de comparatie pentru o solutie la aceasta problema.

Retineti ca SWI Prolog face unele lucruri aparent ciudate in domeniul de aritmetica:

?- X is [a].
X = 97.

?- X is [a] + [b].
X = 195.

?- X is sqrt(23456).
X = 153.154.

?- X is sqrt([23456]).
X = 153.154.

?- X is sqrt(123456789).
X = 11111.1.

?- X is sqrt([123456789]).
X = 13.3791.

Codul ASCII pentru o este de 97, ceea ce explica un fel de primele doua rezultate de interogare. Ultima pereche de interogari sunt deosebit de ciudate. Cel mai bine este sa se evite bazandu-se pe acest tip de lucru, si stick la notatie aritmetice standard. Evitati trucuri ciudat: cod ar trebui sa fie usor de inteles.

A se vedea, de asemenea, operatorii de comparatie, functii predefinite.

aritate

Aritatea un functor este numarul de argumente este nevoie. De exemplu, aritatea likes, la fel ca in likes(jane, pizza), este de 2, ca este nevoie de doua argumente, jane si pizza.

Aritate	Exemplu	Ar putea sa insemne...
0	linux.	un pic cum ar fi #define LINUX in * C
1	happy(fido).	Fido este fericit.
2	likes(jane, pizza).
3	gave(mary, john, book).	Maria a dat o carte Ioan.

* Greu de utilizat in practica in Prolog: in cazul in care codul contine linux. atunci ai putea sa testeze pentru acest lucru, dar daca nu, atunci testarea linux in codul dvs. va declansa o "procedura de nedefinite: linux / 0" eroare. Aveti posibilitatea sa lucrati in jurul valorii de acest lucru prin declararea linux care urmeaza sa fie dinamica - si anume punerea linia

:- dynamic linux/0.

in codul dvs. (de obicei la inceputul).

Fiecare fapt si de regula intr-un program Prolog, si fiecare predicat built-in are o aritatea. Deseori, acesta este mentionata in descrierile de aceste fapte si norme, prin adaugarea / si aritatea la numele statului sau de fapt. De exemplu, built-in predicat membru / 2 are aritatea 2.

Un fapt sau norma poate avea mai mult de un aritatea. De exemplu, ati putea dori sa aiba doua versiuni de make ceea ce priveste:

% make(X, Y, Z): X makes Y for Z
make(fred, chest_of_drawers, paul).
make(ken, folding_bicycle, graham).

% make(X, Y): X makes Y
make(steve, fortune).
make(kevin, mistake).

Ceea ce avem aici se make/3 si make/2.

assert, asserta, assertz

afirma este o meta-predicat care adauga argumentul sau unic, care poate fi un fapt sau o regula, la baza de date Prolog. Ideea este ca voi construi sau invata un fapt nou sau norma in curs de executare program Prolog, si doriti sa-l adaugati la baza de date. asserta asigura ca faptul adaugat / regula, se adauga inainte de orice alte fapte sau cu normele acelasi functor ), in timp ce assertz adauga faptul ca dupa orice alte norme sau fapte cu acelasi functor. Atunci cand mai mult de o regula / fapt cu acelasi functor este prezenta in baza de date, ei sunt judecati in ordinea in care ele apar in baza de date, de unde si nevoia de asserta si assertz. Tu ar folosi asserta in cazul in comun in cazul in care se presupune fapt nou pentru a salva efortul implicat in verificarea faptului utilizand reguli si alte fapte. S-ar putea folosi assertz, de exemplu, daca ati fost incercarea de a construi o structura de date coada (in cazul in care elementele sunt adaugate la sfarsitul cozii de asteptare Exemple.:

?- assert(rich(mary)).
true.

?- rich(mary).
true.

?- assert((happy(X) :- rich(X), healthy(X))).
X = _G180

?- assert(healthy(mary)).
true.

?- happy(X).
X = mary

Fapte / reguli care sunt incarcate dintr-un fisier nu poate fi amestecat cu fapte / reguli, care sunt create folosind assert / asserta / assertz fara a tine pasul speciale de declarare a procedurii in cauza sa fie dinamica. De exemplu, daca aveti o regula sa spun, calcula N, cu antet! factorial(+N, -Result), adica cu functor factorial si Arity 2, si, de asemenea, va doriti sa utilizati asserta pentru a adauga pre-calculate valorile unor factorialele la baza de date Prolog (a se vedea, de asemenea, memoisation ), atunci va trebui sa declare factorial care urmeaza sa fie dinamic, inclusiv prin urmatorul text cu normele dvs. incarcate pentru factorial :

:- dynamic factorial/2.

Programe cu assert Ed faptele si normele pot fi foarte greu pentru a depana.

Vezi de asemenea si retract, retractall, dynamic.

atom

Un atom, in Prolog, inseamna un singur element de date. Acesta poate fi de unul dintre cele patru tipuri:

• un atom de sir de caractere, cum ar fi "Acesta este un sir", sau
• un simbol, ca likes, john, si pizza, in likes(john, pizza). Atomii de acest tip trebuie sa inceapa cu o litera minuscula. Acestea pot include cifre (dupa initiala minuscule litera) si caracterul subliniere ( _ ).
• lista goala []. Acesta este unul ciudat: alte liste nu sunt atomi. Daca va ganditi la un atom ca ceva care nu este divizibil in parti (sensul originar al atomului de cuvant, desi subminata de fizica subatomica), apoi [] fiind un atom este mai putin surprsing, deoarece cu siguranta nu este divizibil in parti.
• siruri de caractere speciale, cum ar fi <--->, ..., ===>. Cand se foloseste atomi de acest tip, unele este nevoie de ingrijire pentru a evita folosirea siruri de caractere speciale, cu un sens predefinit, cum ar fi gat simbol :-, taiate simbol !, si diverse aritmetica si compararea operatorilor.
  Caracterele disponibile speciale pentru construirea aceasta clasa de atom sunt: +, -, *, /, <, >, =, :, ., &, _, si ~.

Numeri, in Prolog, nu sunt considerate a fi atomi.

atom este, de asemenea, numele unui predicat built-in, care testeaza daca argumentul sau unic este un atom.

?- atom(pizza).
true.

?- atom(likes(mary, pizza)).
false.

?- atom(<-->).
true.

?- atom(235).
false.

?- X = some_atom, atom(X).
X = some_atom.

Ultimul exemplu ce inseamna ca atom(X) a reusit, cu X legat de some_atom.

atom_chars

Built-in predicat Prolog atom_chars face conversia unui atom in lista de scrisori sale constitutive, sau vice-versa. Un concept destul de larg de atom este utilizat: acest predicat va lipici impreuna (sau divizat) orice caractere rezonabil-o dai. O lista posibila ar fi de a pune impreuna o lista de litere citit, cate un caracter la un moment dat, pentru a face un cuvant - care este, un atom al carui nume este cuvantul. Exemple:

?- atom_chars(pizza, List).
List = [p, i, z, z, a]

?- atom_chars(Atom, [b, e, e, r]).
Atom = beer

?- atom_chars(2007, List).
List = ['2', '0', '0', '7']

?- atom_chars(Atom, ['[', '3', ' ', ',', '4', ']']).
Atom = '[3 ,4]' 

A se vedea, de asemenea, atom_codes.

atom_codes

Built-in predicat Prolog atom_codes face conversia unui atom in lista de coduri numerice utilizate pe plan intern pentru a reprezenta personajele din atom, sau vice-versa. Exemple:

?- atom_codes(pizza, List).
List = [112, 105, 122, 122, 97] 

?- atom_codes(Atom, [98, 101, 101, 114]). 
Atom = beer 

A se vedea, de asemenea, atom_chars.

backtracking

Backtracking este de fapt o forma de cautare. In contextul de Prolog, sa presupunem ca interpretul Prolog incearca sa satisfaca o secventa de goluri goal_1, goal_2. In cazul in care interpretul Prolog gaseste un set de variabile legaturi care permit goal_1 sa fie indeplinite, ea se angajeaza la aceste legaturi, si apoi incearca sa satisfaca goal_2. In cele din urma unul din doua lucruri se intampla: (a) goal_2 este indeplinita si terminat cu, sau (b) goal_2 nu pot fi satisfacute. In ambele cazuri, backtracks Prolog. Asta este, "ne-angajeaza" sa se legaturi variabila a facut in satisfacerea goal_1 si merge in cautarea unui alt set de variabile care permit legaturi goal_1 care urmeaza sa fie indeplinite. Daca gaseste un al doilea set de astfel de legaturi, se angajeaza sa le si veniturile pentru a incerca sa satisfaca goal_2 din nou, cu legaturi noi. In cazul in care (a), interpretul Prolog este in cautarea de solutii suplimentare, in timp ce in cazul (b) este inca in cautarea pentru prima solutie. Deci, backtracking pot servi pentru a gasi solutii suplimentare pentru o problema, sau sa continue cautarea pentru o solutie in primul rand, atunci cand un prim set de ipoteze (de exemplu legaturi variabila) se dovedeste a nu sa duca la o solutie.

Exemplu: aici este definitia built-in predicat Prolog member :

member(X, [X | Rest]). % X is a member if its the first element
member(X, [Y | Rest]) :-
    member(X, Rest).   % otherwise, check if X is in the Rest

Nu aveti dreptul sa cred ca de member ca un predicat backtracking, dar backtracking este construit in Prolog, deci in conditii adecvate, member vor cale intoarsa:

?- member(X, [a, b, c]).
X = a ;
X = b ;
X = c ;
false.

Aici member backtracks pentru a gasi orice solutie posibila interogarea dat sa-l. Luati in considerare, de asemenea:

?- member(X, [a, a, a]).
X = a ;
X = a ;
X = a ;
false.

Aici member backtracks, chiar daca pastreaza pe gasirea acelasi raspuns. Ce zici de

?- member(a, [a, a, a]).
true ;
true ;
true ;
false.

Acest lucru se datoreaza faptului ca Prolog are trei moduri de a dovedi ca a este un membru al [a, a, a].

Backtracking termen lung, de asemenea, trebuie sa cauti mai multe seturi de legaturi variabila pentru a satisface un singur gol.

In anumite circumstante, ar putea fi de dorit sa se inhiba backtracking, ca atunci cand doar o singura solutie este necesara. Prolog taiat Scopul permite acest lucru.

Tracing executarea de o bucata de cod Prolog care backtracks poate fi o modalitate buna pentru a afla ce se intampla in timpul backtracking. Daca ati fi dorit sa experimenteze cu backtracking prin trasarea member, ai putea realiza acest lucru prin copierea codului de member, avand in vedere mai sus, schimbarea numelui de member sa spun mem in cele trei locuri unde se pare, si apoi urmarirea dvs. mem procedura.

bagof

Built-in predicat bagof(+Template, +Goal, -Bag) este utilizat pentru a colecta o lista Bag a tuturor elementelor Template care indeplinesc un scop Goal. Exemplu: presupunem

likes(mary, pizza).
likes(marco, pizza).
likes(Human, pizza) :- italian(Human).
italian(marco).

Apoi

?- bagof(Person, likes(Person, pizza), Bag).
Person = _G180
Bag = [mary, marco, marco]

Observati ca Bag contine elementul marco de doua ori, pentru ca exista doua modalitati de a dovedi ca marco place pizza -. fapt si prin intermediul regula bagof esueaza daca Goal nu are solutii.

A se vedea, de asemenea, setof, si, pentru diferentele intre bagof si findall, a se vedea findall.

obligatoriu

Legarea este un cuvant folosit pentru a descrie da o valoare intr-o variabila. In mod normal are loc in timpul aplicarii unei reguli Prolog, sau o incercare de a satisface goluri intr-un Prolog interogare.

Sa presupunem ca baza de date Prolog contine doar faptul unica likes(mary, pizza). si ca exista o interogare:

?- likes(mary, What).

Prolog va cauta in baza de date (foarte mici), constata ca interogarea poate fi indeplineste daca What = pizza, nu-l va lega What sa pizza succes si sa raporteze:

?- likes(mary, What).
What = pizza ;
false.

Acum, sa presupunem ca exista o regula si fapte in baza de date Prolog:

teaches(Teacher, Student):-
    lectures(Teacher, Subject), studies(Student, Subject).
lectures(codd, databases).
studies(fiona, databases).
studies(fred, databases).

si ca ghidul de problemele interogare:

?- teaches(codd, Who).

Interpretul Prolog primele meciuri seful statului cu interogarea, si se leaga atat de Teacher la codd. El gaseste apoi un fapt care indica faptul ca un subiect prelegeri Codd - si anume lectures(codd, databases). In acest moment, variabila Subject este legat de databases ( Subject = databases ). Cu alte cuvinte, Subject, probabil temporar, are valoarea databases. Apoi, Prolog incearca sa satisfaca de-al doilea scop studies(Student, Subject) cu Subject = databases, adica incearca sa satisfaca studies(Student, databases). Atunci cand gaseste solutia, studies(fiona, databases) se va lega Subject la fiona, si sa raporteze solutia:

?- teaches(codd, Who).
Who = fiona

Observati ca legarea Subject = databases a fost facuta in rezolvarea interogare, dar aceasta nu este raportat, deoarece nu este in mod explicit parte a interogarii.

Apoi, in cazul in care utilizatorul tasteaza " ;", Prolog va revina si anula obligatoriu Student = fiona si pentru a cauta o alta valoare pentru Subject ca indeplineste studies(Student, databases), precum si pentru a gasi Student = fred. Cu toate acestea, desi sunt obligatorii (si desfacere) este implicat in aceasta etapa, este tratat corespunzator sub backtracking.

corp

ultima parte a unei Prolog regula. Acesta este separat de cap de gat simbolul, scrise ca :-. Ea are forma unei liste separate prin virgula de obiective, fiecare dintre care este un functor, eventual urmata de o lista separata prin virgula de argumente, in paranteze. De exemplu, in regula

sister_of(X,Y) :- female(Y), X \== Y, same_parents(X,Y).

cele trei goluri female(Y), X \== Y, same_parents(X,Y) forma corpului.

built-in predicat

Pentru a face programare Prolog mai practice, un numar de predicate sau sunt construite in Prolog. Acestea includ unele proceduri de utilitate, care ar fi putut fi programate de catre utilizator Prolog, si unele care fac lucruri non-logica de programare, cum ar fi de intrare si de iesire rutine, rutine depanare, si o serie de alte persoane.

Bratko

Acest lucru se refera la textul utilizat in COMP9414/9814 de la Universitatea din New South Wales, Australia:
Bratko, I., de programare in Prolog pentru Inteligenta Artificiala, Editia a 4, Addison-Wesley, 2011

built-in functii, abs, atan, ceiling, cos, exp, float, floor, log, round, sign, sin, sqrt, tan, truncate

Un numar mic de functii matematice sunt construite in Prolog, inclusiv:

Functie	Semnificatie
abs(Exp)	Valoarea absoluta a Exp: Exp adica daca Exp? 0, daca-Exp Exp <0
atan(Exp)	arctangenta (tangentei inversa) de Exp: Rezultatul este in radiani
cos(Exp)	cosinus de Exp: Exp este in radiani
exp(Exp)	Exp e: e este 2.71828182845...
log(Exp)	logaritmul natural al Exp: logaritmului si anume la baza * e
sin(Exp)	sinusul Exp: Exp este in radiani
sqrt(Exp)	radacina patrata a Exp
tan(Exp)	tangenta Exp: Exp este in radiani
sign(Exp)	semn (+1 sau -1) din Exp: semnul (-3) = -1 = sign (-3.7)
float(Exp)	float de Exp: float (22) = 22.0 - a se vedea, de asemenea, float predicat
floor(Exp)	cel mai mare numar intreg? Exp: podea (1.66) = 1
truncate(Exp)	elimina o parte fractionara a Exp: trunchia (-1.5) = -1, trunchia (1,5) = 1
round(Exp)	Exp runda la cea mai apropiata numar intreg: rotund (1.6) = 2, a runda (1.3) = 1
ceiling(Exp)	cel mai mic numar intreg? Exp: plafon (1.3) = 2

Aceste functii ar trebui sa fie utilizate intr-un context in care acestea vor fi evaluate de fapt, cum ar fi urmatorul text is sau ca parte dintr-o aritmetica operator de comparatie precum =:= sau >.

Exemplu:

?- X is sqrt(2).
X = 1.41421 

Comparati acest lucru cu urmatorul text, in cazul in care sqrt (2) nu este evaluat, deoarece = nu evalueaza argumentele sale.

?- X = sqrt(2).
X = sqrt(2) 

Un alt exemplu:

?- X is log(3+2).
X = 1.60944.

Aceste functii matematice poate corespunde aritate 2 predicate built-in: de exemplu, se poate face acest lucru:

?- sqrt(2, X).
X = 1.41421

Unele versiuni de SWI Prolog (de exemplu, 5.6.47) pune in aplicare multe dintre aceste aritate 2 predicate, dar nu de exemplu, exp/2.

* Liceul de Matematica Serviciul memento: daca doriti logaritmul in baza o, divide log (Exp) de log (a). De exemplu, log ₁₀ (x) = log (X) / log (10), si log ₂ (X) = log (X) / log (2).

call

call este un built-in meta-predicat, care permite argumentul sau unic de a fi numit / invocat ca un obiectiv. De exemplu, un program ar putea crea un gol (probabil folosind =.. ) cu privire la zbor, si apoi, probabil mai tarziu in program, necesitatea de a testa obiectivul. Aici sunt interogari care efectua aceste roluri - intr-un program real, atat assert si call va fi construit in procedurile Prolog scrise de catre programator.

?- assert(likes(mary, pizza)).

?- call(likes(Person, pizza)).
Person = mary

?- Goal =.. [likes, mary, What], call(Goal).
Goal = likes(mary, pizza)
What = pizza

clauza

O clauza in Prolog este o unitate de informatii intr-un program Prolog se termina cu un punct (" . "). O clauza poate fi un fapt, cum ar fi:

likes(mary, pizza).
food(pizza).

sau o regula, cum ar fi:

eats(Person, Thing) :- likes(Person, Thing), food(Thing).

O clauza poate fi, de asemenea, o interogare pentru a interpretului Prolog, la fel ca in:

?- eats(mary, pizza).

Un grup de clauze cu privire la aceeasi relatie este numita procedura.

comentand codul

In Prolog, un inceput de un comentariu este semnalizata cu caracterul %. Comentariile sunt ignorate de catre interpret Prolog, scopul lor este de a ajuta un cititor uman sa inteleaga codul Prolog. Exemple:

% This is a full line comment.
% The next line contains a part-line comment.
member(Item, [Item|Rest]). % member succeeds if Item is 1st object in list.

Orientarile Comentand

Ca si in alte limbaje de programare, comentariile ar trebui sa fie utilizate in mod liber pentru a explica semnificatia la nivel inalt de sectiuni de cod, pentru a explica sectiuni complicat de cod, etc Comentariile nu ar trebui sa ecou ceea ce codul deja spune clar. Comentariile de genul asta ajunge de fapt in calea de intelegere, de exemplu, deoarece acestea sunt susceptibile de a face pe cititor ignora comentariile. In cazul in care este posibil sa se faca inteles de cod cu ajutorul unui semnificative functor numele sau variabila nume, acest lucru este de preferat un comentariu.

Este o practica buna pentru a incepe fiecare procedura Prolog cu un comentariu care descrie ceea ce face, de exemplu,

% member(Item, List) - succeeds if the item is a member of the list

In cazul in care lista trebuie sa aiba unele proprietati speciale, de exemplu, in cazul in care trebuie sa fie o lista de numere, sau trebuie sa fie instantiat (care este, au o valoare), in momentul in care procedura se numeste, atunci acest comentariu antet ar trebui sa spun asa:

% member(Item, List) - succeeds if the item is a member of the list;
%   List must be instantiated at the time member is called. Item need not
%   be instantiated.

Acesta poate fi o idee buna pentru comentariile antet pentru a indica exemple de tipul de date pe care procedura este destinat sa functioneze, si ce rezultat ar trebui sa fie, daca acest lucru poate fi realizat in mod rezonabil pentru scurt timp. De exemplu,

% Examples of use:
% ?- member(b, [a, b, c]).
% true.
% 
% ?- member(X, [a, b, c]).
% X = a ;
% X = b ;
% X = c ;
% false.

Fiecare fisier de cod Prolog ar trebui sa inceapa cu un comentariu antet (fisier), indicand care a scris codul, atunci cand, si ceea ce este (in ansamblu) intentioneaza sa faca. Acest lucru ar fi de ajuns intr-o misiune Prolog scurt. Intr-un sistem de "rezistenta industrial" Prolog, nu ar exista detalii cu privire la originile de algoritmi folosit, si o istorie revizuire.

O buna sursa de exemple de Prolog este comentarea exemplu codul puse la dispozitie in clasa, cum ar fi aceasta. Notati, totusi, ca aceasta este mai degraba mai comentat foarte intens decat de obicei, in scopuri de instruire. Retineti, de asemenea, ca a prezentat exemple de cod de pe ecran pot fi sub-comentat, din cauza dificultatii de montare comentariile si codul de pe ecran, si pentru ca prezentarea orala de insotire a materialelor de pe ecran inlocuieste comentariile intr-o anumita masura.

Nu face liniile de comentarii (sau codul) prea mult timp - linii lungi poate fi greu de citit, si linii foarte lungi pot fi indoite, de cotitura formatarea tau ingrijit intr-un mic dejun cainelui. Stick la o lungime linia de grad maxim de 70 sau 80 de caractere. Cute linii si / sau cutii construite de caractere in comentariu au efect secundar de a impiedica cititorul sa vada cat mai mult de cod la un moment dat. Cititorul poate avea apoi la pagina in sus si in jos pentru a afla ce codul dvs. nu. Ei nu va va place pentru aceasta.

Utilizarea de bucati in mod normal, ar trebui sa fie comentate sa explice de ce este necesara taiat.

Este o idee proasta pentru a comenta (aproape) fiecare linie, in parte din cauza dezordine, si ca aceasta cauzeaza distragere, si, partial, pentru ca cele mai multe astfel de comentarii sunt inutile duplicari de cod (si / sau in comentariu lucruri evidente, cu exceptia Prolog la o novice programator):

Exemplu de Bad comentand (fiecare linie de comentat):

factorial(0, 1).                     % Factorial of 0 is 1.
factorial(N, FactN) :-
    N > 0,                           % N is positive
    Nminus1 is N - 1,                % Calculate N minus 1
    factorial(Nminus1, FactNminus1), % recursion
    FactN is N * FactNminus1.        % N! = N * (N - 1)!

Dintre aceste comentarii, doar prima si ultima sunt chiar slab justificate, si chiar si acestea sunt, probabil, prea evident, ca, mai ales pentru ultimul comentariu, numele variabilei sa va spun tot ce ai nevoie sa stii. Se pare destul, cu toate % semnele-frumos aliniate, dar fortele de cititor pentru a verifica prin toate comentariile inutile in cazul in care exista nimic important acolo. Acest cod are nevoie de un comentariu antet procedura, si, probabil, nimic altceva, desi un programator Prolog inceput ar putea fi justificata in subliniind faptul ca linia N > 0, este acolo pentru a va asigura ca regula este utilizata numai in cazul in care N este pozitiv. (Daca nu sunteti sigur de ce acest lucru este atat de important, incercati sa lasati afara N > 0, si de testare privind functia spune N = 2.) Deci in comentariu ar fi " % only use rule if N > 0. "

Cum de a scrie comentarii si mai rau!

Este usor - doar scrie comentarii care sunt de fapt gresite.
Opinie comentariile dvs. intr-un moment rece, si asigurati-va ca ceea ce spun ei este adevarat.

+ -? conventie pentru procedurile de argumente pentru a

O conventie adesea utilizate pentru a face rolul de argumente intr-o procedura mai clara este de a le eticheta cu +, –, si ?, dupa cum urmeaza:

Eticheta	Semnificatie
+	Argumentul este de asteptat sa fie instantiat (de exemplu, au o valoare mai degraba decat sa fie o variabila) in cazul in care procedura se numeste ca un scop.
–	argument este de asteptat sa fie o variabila de a fi legat in cazul in care procedura se numeste ca un scop.
?	argument poate fi instantiata, sau poate fi o variabila nelegat, in cazul in care procedura se numeste ca un scop.

Exemplu:

% factorial(+N, -FactorialN).
%% supply a value for N, and FactorialN will be computed.

% member(?Item, ?List).
%% Item and List may either be instantiated, or a variable
%% (but in fact at least one of them must be instantiated!)

Merita verificarea, apropo, ce se intampla daca List nu este instantiat...

?- member(a, List).

List = [a|_G231] ;

List = [_G230, a|_G234] ;

List = [_G230, _G233, a|_G237] 

si asa mai departe... Prolog fabrica drum prin toate structurile lista care contin a.

Ortografie, gramatica, etc

Nu este nici un lucru rau, daca toate aceste comentarii sunt scrise corect gramatical si sunt formulate. (Uneori este necesar sa se abrevierea, asa ca, probabil comentariile dvs. nu toate trebuie sa fie Exemple de plin.) Aceasta face viata mai greu pentru oameni incercarea de a citi codul, in cazul in care trebuie sa Wade prin ortografie sarace si gramatica. Amintiti-va ca oameni care citesc codul de dvs. va include persoanele pe care vor dori sa inteleaga comentariile dvs. cu usurinta - ajutoare, markere, colegii, seful tau, chiar va in timp de un an de cand ati uitat cum ai ajuns codul pentru a lucra... Asa ca in bune obiceiuri comentand de la inceput.

A se vedea, de asemenea, indentarea si spatiu alb.

Compara operatorii

(. Numai unele dintre operatorii de mai jos sunt relevante pentru COMP9414 la Universitatea din New South Wales - a se vedea de colorat verde de mai jos) Prolog are doua clase principale de operatorii de comparatie - operatorii de comparatie aritmetica (si similare operatori alfabetice comparatie) si unificarea stil-operatorii:

Comparatie	Definitie	Evalueaza?
X = Y	reuseste daca X si Y unifica (meci), in sensul Prolog	Nu
X \= Y	reuseste daca X si Y nu unifica, adica daca not (X = Y)	Nu
T1 == T2	daca reuseste termeni T1 si T2 sunt identice; de??exemplu, numele de variabile trebuie sa fie aceeasi	Nu
T1 \== T2	daca reuseste termeni T1 si T2 nu sunt identice	Nu
E1 =:= E2	reuseste daca valorile expresii E1 si E2 sunt egale	Da
E1 =\= E2	reuseste daca valorile expresii E1 si E2 nu sunt egale	Da
E1 < E2	reuseste daca valoarea numerica a expresiei E1 este <valoarea numerica a E2	Da
E1 =< E2	reuseste daca valoarea numerica a expresiei E1 este? valoarea numerica a E2	Da
E1 > E2	reuseste daca valoarea numerica a expresiei E1 este> valoarea numerica a E2	Da
E1 >= E2	reuseste daca valoarea numerica a expresiei E1 este? valoarea numerica a E2	Da
T1 @< T2	reuseste daca T1 este in ordine alfabetica <T2	Nu
T1 @=< T2	reuseste daca T1 este in ordine alfabetica? T2	Nu
T1 @> T2	reuseste daca T1 este in ordine alfabetica> T2	Nu
T1 @>= T2	reuseste daca T1 este in ordine alfabetica? T2	Nu

A se vedea, de asemenea, is. is nu este un operator de comparatie, dar este adesea confundat cu = de catre programatorii Prolog novice. Pe scurt, utilizati X is Exp pentru a evalua o expresie aritmetica, cum ar fi Y + 2, care contine un operator aritmetic, cum ar fi +, si se leaga valoarea rezultata la variabila X la stanga a operatorului is.

Ca un exemplu de @< si rudele sale,

?- likes(mary, pizza) @< likes(mary, plums).
true.

Acest lucru reuseste pentru ca likes si mary sunt aceleasi, atat in termeni, si pizza in ordine alfabetica precede plums.

Comparatie de numere fractionare: Cand se compara doua numere fractionare, pot aparea probleme de natura aproximative de reprezentari de numere fractionare in computere. Uneori, acesta va lucra ca de asteptat, si, uneori, nu. De exemplu, interogarea 1.21 =:= 1.1 * 1.1. esueaza cu SWI Prolog pe calculator in cazul in care acest articol a fost scris. Puteti si ar trebui sa functioneze in jurul valorii de aceasta problema de catre, in loc de testare numere fractionare pentru egalitatea de sanse, face ceva de genul urmator:

?- abs(1.21 - 1.1 * 1.1) < 0.000001.
true.

abs inseamna "valoare absoluta": abs(X) = X daca X >= 0 si abs(X) = -X daca X =< 0.
Mai mult, in general, de testare pentru abs(X - Y) < Tiny, in cazul in care Tiny este obligat sa numar mic (sau este un numar mic, ca in exemplul). Cat de mica pentru a face Tiny de mai sus depinde de la caz la caz - va trebui sa utilizati un numar mai mic in cazul in care X si Y trebuie sa fie foarte aproape impreuna pentru a face munca algoritm corect.

consult

Aceste pre-definite pseudo-predicate permite o pentru a incarca cod Prolog intr-un interpret Prolog executa. Exemplu:

?- consult('myprogram.pl').

Aceasta incarca continutul programului Prolog in fisierul myprogram.pl in baza de date Prolog executa lui. Retineti ca, in SWI Prolog, cel putin, inainte de a incarca noile fapte si norme in baza de date, Prolog elimina primul toate faptele si normele care se refera la procedurilor in myprogram.pl. Deci, daca myprogram.pl contine, de exemplu, faptul likes(jane, pizza) apoi toate faptele si normele cu privire la likes, care au doua argumente vor fi sterse din baza de date Prolog inainte de fapte noi in myprogram.pl sunt incarcate in sus. Acest lucru este convenabil atunci cand sunt utilizati consult pentru a re-incarcati un program de editare dupa aceasta (de exemplu, intr-o alta fereastra, cu interpretul Prolog stanga de functionare), dar ar putea fi un pic surprinzator daca ati fost incercarea de a incarca fapte suplimentare dintr-un fisier.

Este posibil sa se consulte mai mult de un fisier la un moment dat, prin inlocuirea numele singur fisier cu o lista de fisiere:

?- consult(['file1.pl', 'file2.pl', 'file3.pl']).
% file1.pl compiled 0.00 sec, 524 bytes
% file2.pl compiled 0.01 sec, 528 bytes
% file3.pl compiled 0.00 sec, 524 bytes
true.

De asemenea, este posibil sa se consulte abrevierea un apel, pur si simplu tastati lista de (unul sau mai multe), fisiere ca un obiectiv pentru Prolog:

?- ['file1.pl', 'file2.pl', 'file3.pl'].

In unele implementari Prolog, consultarea user cauze interpretului Prolog pentru a citi faptele si normele de terminal al utilizatorului in:

?- [user].
|: likes(jane, pizza).
|: bad_dog(Dog) :-
|:    bites(Dog, Person),
|:    is_human(Person),
|:    is_dog(Dog).
|: <control-D>
% user://1 compiled 0.00 sec, 1,156 bytes
true.
?- 

curentul de intrare fluxul

La un moment dat, contributia la Prolog vine de la "fluxul de intrare curent". Atunci cand Prolog porneste, fluxul de intrare curent este tastatura de calculator / statie de lucru de la care Prolog a fost pornit.

Cu toate acestea, s-ar putea dori pentru a obtine de intrare / citire de la alta parte in timpul executarii programului Prolog dvs. - de exemplu, ati putea dori sa citeasca dintr-un fisier a avut loc pe computerul pe care programul se executa, sau pe un server local de fisiere. Pentru a schimba fluxul de intrare curent, utilizati Prolog built-in extra-logic predicat see. Daca Prolog executa gol see('input.dat'), atunci va veni ulterior de intrare din fisierul input.dat, in directorul curent de lucru a * statia de lucru care se executa Prolog. Daca fisierul specificat nu poate fi gasit in directorul de lucru curent, o eroare pot fi raportate, ca si in aceasta interactiune cu SWI Prolog:

?- see('nosuchfile.dat').
ERROR: see/1: source_sink `nosuchfile.dat' does not exist (No such file or directory)

Alte erori sunt posibile - ar putea sa nu aiba dreptul de a citi dosarul in cauza, de exemplu. Daca fisierul nu exista si este usor de citit, apoi operatiunile ulterioare citi obtine date de la dosar. Parametru pentru a see poate fi doar numele de fisier, cum este ilustrat mai sus, sau ar putea fi o cale spre fisierul care este dorit: de exemplu, see('/Users/billw/prologstuff/input.dat') Prolog va continua sa emita solicitari pentru mai multe interogari in timp ce se "vede" un fisier, dar toate operatiile explicit citire a accesa fisierul. Built-in extra-logice predicat seen (cu nici un argument) va permite sa reveniti la citirea datelor de la tastatura. Exemplu (presupunand info.dat incepe cu linia de hungry(jack). ):

?- see('info.dat'), read(X).
X = hungry(jack)

?- seen, read(Y).
|: full(jack).
Y = full(jack)

A se vedea, de asemenea, fluxul de iesire curent, intrare, iesire, fisierele.

* Strict vorbind, input.dat va fi de asteptat sa fie in directorul de lucru curent de interpretorul de comenzi, care a inceput Prolog. Interpretor de comenzi vor fi difuzate pe statia de lucru / calculator, si trimiterea de iesire intr-o fereastra pe care statie de lucru sau calculator.

fluxului de curent de iesire

La un moment dat, de intrare pentru a merge la Prolog "stream curent de iesire". Atunci cand Prolog porneste, fluxul de curent de iesire este fereastra sau consola de statii de lucru calculatorul / de la care Prolog a fost pornit. Cu alte cuvinte, atunci cand programul scrie lucruri folosind predicatele descrise in articol pe scris, acestea apar pe ecran.

Cu toate acestea, ati putea dori sa scrie in alta parte in timpul executarii programului Prolog dvs. - de exemplu, ati putea dori sa scrie intr-un fisier a avut loc pe computerul pe care programul se executa, sau pe un server local de fisiere.

Pentru a schimba fluxul curent de iesire, utilizati una dintre Prolog built-in extra-logice predicate tell si append/1 *. Daca Prolog executa obiectivul tell('output.dat'), apoi de iesire va merge ulterior la dosar output.dat, in directorul curent de lucru a * statia de lucru care se executa Prolog.

Daca fisierul specificat nu poate fi gasit in directorul de lucru curent, acesta va fi creat. Daca fisierul nu exista, acesta va fi suprascris. Daca utilizati append/1, operatiunile ulterioare a scrie va adauga material la sfarsitul fisierului, in loc de a suprascrie fisierul. Daca nu aveti permisiunea de a scrie fisiere in directorul curent, veti vedea un mesaj de eroare:

?- tell('/usr/bin/ztrash').  
ERROR: tell/1: No permission to open source_sink `/usr/bin/ztrash' (Permission denied)

Acest lucru inseamna ca fie nu aveti permisiunea de a scrie fisiere in directorul /usr/bin, sau daca fisierul ztrash exista deja in acest director, ca nu aveti permisiunea de a scrie in acest fisier.

In cazul in care fisierul este in masura sa fie scris, apoi operatiunile ulterioare a scrie trimite datele lor de la dosar. Parametrul de a tell poate fi o cale catre fisier care este dorit, ca in exemplul de mai sus, sau ar putea fi doar numele de fisier, de exemplu, tell('output.dat'). Prolog va continua sa emita solicita pentru mai multe interogari si legaturi de imprimare in timp ce sunt "spune" sau "adaugarea" un fisier, dar toate operatiile explicit scriere a accesa fisierul. Built-in extra-logice predicat told (cu nici un argument) va permite sa reveniti la scrierea de date de fereastra originala. Exemplu:

?- tell('info.dat'), write(thirsty(jack)), nl.
true.
?- told, write(drunk(jack)).
drunk(jack)
true.
?- halt.
% cat info.dat # - # is Unix comment char, cat lists info.dat
thirsty(jack)
% 

A se vedea, de asemenea, fluxul de intrare curent, de intrare, iesire, fisierele.

* append/1 nu este legat de append/3, care, la randul sau, nu are nimic de-a face cu fluxuri de iesire.

# Strict vorbind, output.dat va fi de asteptat sa fie in directorul de lucru curent de interpretorul de comenzi, care a inceput Prolog. Interpretor de comenzi vor fi difuzate pe statia de lucru / calculator, si trimiterea de iesire intr-o fereastra pe care statie de lucru sau calculator.

taiate,!

Taiat, in Prolog, este un obiectiv, scris ca !, care reuseste mereu, dar nu poate fi regresat trecut. Este utilizat pentru a preveni backtracking nedorite, de exemplu, pentru a preveni solutii de suplimentare a fost gasit de catre Prolog.
Taietura trebuie sa fie folosit cu economie. Exista o tentatie de a introduce reduceri experimental intr-un cod care nu functioneaza corect. Daca veti face acest lucru, tineti minte ca atunci cand depanare este complet, ar trebui sa inteleaga efectul, si sa fie capabili sa explice necesitatea, fiecare taiat utilizati. Utilizarea unei reduceri ar trebui sa fie, astfel, comentate.

Exemplu: Sa presupunem ca avem urmatoarele fapte:

teaches(dr_fred, history). teaches(dr_fred, english). teaches(dr_fred, drama). teaches(dr_fiona, physics).

studies(alice, english). studies(angus, english). studies(amelia, drama). studies(alex, physics).

Apoi ia in considerare urmatoarele interogari si iesirile lor:

?- teaches(dr_fred, Course), studies(Student, Course).

Course = english
Student = alice ;

Course = english
Student = angus ;

Course = drama
Student = amelia ;

false.

Backtracking nu este inhibata aici. Course este initial legat de history, dar nu exista elevi de history, astfel incat obiectivele doilea esueaza, backtracking apare, Course este re-legat de english, al doilea scop este de incercat si de cele doua solutii gasite ( alice si angus ), apoi backtracking se produce din nou, si Course este legat de drama, si o finala Student, amelia, se gaseste.

?- teaches(dr_fred, Course), !, studies(Student, Course).

false.

Acest timp Course este initial legat de history, atunci scopul taiat este executat, iar apoi studies Scopul este incercat si nu reuseste (pentru ca nimeni nu studies history ). Din cauza taiate, nu putem sa revina teaches scopul de a gasi un alt caracter obligatoriu pentru Course, astfel incat interogarea intreg esueaza.

?- teaches(dr_fred, Course), studies(Student, Course), !.

Course = english
Student = alice ;

false.

Aici teaches scopul este incercat ca de obicei, si Course este legat de history, din nou, ca de obicei. Inainte studies obiectivul este incercat si nu reuseste, astfel incat noi sa nu ajungem la reducerea de la sfarsitul interogare de la acest punct, si backtracking pot aparea. Astfel, teaches scopul este re-incercat, si a Course este obligata sa english. Apoi studies Scopul este incercat din nou, si reuseste, cu Student = alice. Dupa aceea, obiectivul este de taiat incercat si, desigur, reuseste, astfel incat nu mai este posibila revenire si doar o singura solutie este astfel gasit.

?- !, teaches(dr_fred, Course), studies(Student, Course).

Course = english
Student = alice ;

Course = english
Student = angus ;

Course = drama
Student = amelia ;

false.
?- 

In acest ultim exemplu, aceleasi solutii se gasesc ca in cazul in care nu a fost prezenta taiat, pentru ca niciodata nu este necesar sa se faca cale intoarsa trecut taiat pentru a gasi urmatoarea solutie, astfel incat backtracking nu este inhibata.

Bucati in Regulamentul

In practica, reducerea este utilizat in normele, mai degraba decat in??multi-scop interogari, si unele expresii idiomatice special, se aplica in astfel de cazuri. De exemplu, luati in considerare codul de mai jos pentru max(X, Y, Max), care se presupune de a lega Max cu cel mai mare de X si Y (care se presupune a fi numere).

max(X, Y, X) :- X > Y, !.
max(X, Y, Y).

Aceasta este o modalitate de a spune: "in cazul in care prima regula reuseste, utilizare si nu incercati doua regula (In caz contrar, utilizeaza doua regula.) Am fi putut avea loc in scris.:

max(X, Y, X) :- X > Y.
max(X, Y, Y) :- X =< Y.

caz in care atat norme va fi in mod normal, a incercat (cu exceptia cazului in backtracking este impiedicata de o reducere, in unele alta parte a codului). Aceasta cifra este usor mai putin eficienta in cazul in care X este, de fapt, mai mare decat Y (backtracking inutile apare), dar mai usor pentru oameni sa inteleaga, desi programatori regulat Prolog rapid ajunge sa recunoasca acest tip de idiom. Calculul suplimentare, in cazul de max este triviala, dar, in cazurile in care doua regula implica un calcul lung, ar putea fi un argument puternic pentru utilizarea taiat din motive de eficienta.

depanare

inseamna eliminarea erorilor din codul programului. Acest lucru se face prin (1) respectarea erori (de exemplu, testare ), (2) localizarea cauzei in cod; (3) corectarea erorilor.

(1) si (2) sunt de multe ori partea cea mai grea. Odata ce ati observat sau detectat o eroare, urmarire codul in cauza poate ajuta la descoperirea problemei. Uneori inserarea invita sa write in parti de cod in cazul in care credeti ca problema ar putea fi poate ajuta pentru a localiza eroarea.

In cele din urma, codul de lectura dvs. cu atentie si vor fi parte din sarcina. Asa ca ar fi o idee buna pentru a scrie codul cu atentie in loc primul rand, in scopul de a face mai usor de inteles. A se vedea, de asemenea, de eroare si mesajele de avertizare si comentarea si spatiu alb.

declarativ

Un limbaj de programare declarativ este una in care relatiile dintre date sunt indicate (sau a declarat intr-o limba (de obicei, bazate pe logica), iar apoi un mecanism automat, de exemplu, o teorema-demonstratorului, este utilizat pentru a raspunde intrebarilor cu privire la date. Prolog este un limbaj de programare declarativ. Haskell, Miranda, Lisp, si sistemul sunt limbajele functionale de programare, in care toate constructiile sunt exprimate folosind functii, argumente de functii, si rezultatele functia, si C, C + +, Java, Perl, Pascal, Modula-2, si Fortran sunt exemple de (la nivel inalt) limbile procedurale de programare, in care a codului de program isi exprima procedurile de urmat in manipularea datelor.

dynamic

In Prolog, o procedura este fie statice sau dinamice. O procedura statica este unul al carui fapte / reguli sunt predefinite la inceputul de executare, si nu se schimba in timpul executiei. In mod normal, faptelor / reguli vor fi intr-un fisier de cod Prolog care vor fi incarcate in timpul sesiunii Prolog. Uneori, este posibil sa doriti sa adaugati fapte suplimentare (sau poate chiar normele suplimentara) la procedura, in timpul executarii unei interogari Prolog, folosind assert / asserta / assertz ", sau poate elimina faptelor / normelor folosind retract / retractall. Pentru a face acest lucru, trebuie sa declare procedura sa fie dinamica.

Puteti declara o procedura care urmeaza sa fie dinamica, prin includerea in codul de utilizator (in mod normal, in apropierea faptelor / normele pentru aceasta procedura) un sistem corespunzator de dynamic directiva. Exemplu - sa presupunem ca aveti o procedura numita likes, cu aritate 2 si aveti un "set pentru incepatori" de fapte / normelor in program Prolog dumneavoastra, dar doriti sa deduce fapte suplimentare despre likes in timpul executiei, si adaugati-le la baza de date, astfel incat nu au nevoie sa fie recalculate de fiecare data cand acestea sunt utilizate. [Tu ar fi in mod normal, face acest lucru doar - adaugati fapte noi la baza de date - in cazul in care faptele au fost lente in plus pentru a calcula.] Ai nevoie de a declara likes (cu aritate 2) sa fie dinamica. Poti face acest lucru, dupa cum urmeaza:

:- dynamic likes/2.

[Apropo, observati ca aceasta lasa deschisa posibilitatea ca o versiune diferita a likes (cu aritate 3, spune), ar putea sa nu fie dinamica.]

A se vedea, de asemenea, memoisation.

eficienta

Exista multe modalitati de cod care urmeaza sa fie ineficiente. Acest articol se concentreaza pe problema de a evita inutile apeluri recursive. Luati in considerare urmatorul exercitiu: a scrie un predicat Prolog printOrAdd(IntegerList, Sum) care se leaga numerele chiar din lista sa de intrare IntegerList la o lista EvensList, si in acelasi timp, se adauga pana numere impare in IntegerList si leaga-le la Sum. Aici sunt doua versiuni ale codului, printOrAdd si printOrAdd1 :

% printOrAdd is an inefficient solution to the task posed above:

printOrAdd([], [], 0).

% even numbers
printOrAdd([First | Rest], [First | RestOfEvens], Sum) :-
  printOrAdd(Rest, RestOfEvens, Sum),
  0 is First mod 2.

% odd numbers
printOrAdd([First | Rest], RestOfEvens, Sum) :-

  printOrAdd(Rest, RestOfEvens, SumOfRest),
  1 is First mod 2,
  Sum is SumOfRest + First.

% printOrAdd1 is a corrected version of printOrAdd which
% avoids the unnecessary recursive calls.

printOrAdd1([], [], 0).

printOrAdd1([First | Rest], [First | RestOfEvens], Sum) :-
  0 is First mod 2,
  printOrAdd1(Rest, RestOfEvens, Sum).

printOrAdd1([First | Rest], RestOfEvens, Sum) :-
  1 is First mod 2,
  printOrAdd1(Rest, RestOfEvens, SumOfRest),
  Sum is SumOfRest + First.

?- printOrAdd([1,2,3,4,5,6], Evens, SumOfOdds).
Evens = [2, 4, 6],
SumOfOdds = 9 ;
false.

Prima versiune a face apel recursiv in doua reguli de recursiv inainte de teste pentru a vedea daca First este par sau impar. Daca jumatate din numerele sunt chiar si jumatate ciudat, atunci in mod clar de jumatate din apelurile recursive va fi irosita. Cu toate acestea, situatia este de fapt mult mai rau decat faptul ca, din cauza revenire automata Prolog. Backtracking inseamna ca Prolog va incerca in cele din urma toate cele trei reguli de printOrAdd, si doua dintre ele va determina apeluri recursive, fiecare dintre care se va transforma intr-genera doua apeluri recursive, fiecare dintre care... Astfel, pentru o lista de lungime 100, sa zicem, vor exista mai mult de 2 ^{100 de} apeluri recursive. Daca Prolog ar putea gestiona un miliard de apeluri recursive pe de alta parte, 2 ¹⁰⁰ apeluri recursive ar dura cam 2 ⁷⁰ secunde, sau aproximativ 30 bilioane ani.

Solutia, desigur, este de a testa inainte de a face un apel recursiv, asa cum se procedeaza in printOrAdd1 intotdeauna de testare inainte de a face un apel recursiv;. niciodata apel inainte de a testa.

de eroare si mesaje de avertizare

Mesajele de la interpretul Prolog atunci cand programul tau merge bine poate fi dificil pentru un incepator sa interpreteze. Putin se poate spune, in general, ca mesajele variaza de la sistem la sistem. Puteti gasi un ghid pentru unele dintre mesajele de produse SWI Prolog aici. A se vedea, de asemenea, de subliniere variabile, depanare.

fapt

Un fapt este un Prolog clauza cu un cap cu nici un variabile in ea, si nici un organism, cum ar fi

happy(fred).
likes(mary, pizza).

spre deosebire de aceasta regula :

happy(Person) :-
    healthy(Person),
    enough_money(Person), 
    has_friends(Person).

Clauze fara trup cu variabile, cum ar fi...

member(Item, [Item | RestOfList]).

... Se comporta ca niste reguli, in care acestea ofera un mod general de a sti ca, pentru orice Item, ca item este un membru al unei liste din care aceasta este primul element (a se vedea, de asemenea, membru ). Clauza de mai sus este de natura sa genereze un avertisment SWI Prolog ca acest mesaj:

        Singleton variables: [RestOfList]

sa va spun ca variabila RestOfList este mentionata doar o data in codul (deci poate fi o greseala de ortografie, de exemplu). Puteti suprima avertisment, prin scris, in schimb:

member(Item, [Item | _]).

folosind o variabila tacerea: nu-ingrijire, desi acest lucru poate fi mai dificil pentru un om sa urmeze, in special o beginnner la Prolog.

fail

Built-in predicat Prolog fara nici un argument, care, dupa cum sugereaza si numele, nu reuseste intotdeauna. Utile pentru fortarea backtracking si in alte contexte diferite.

A se vedea, de asemenea, true, repeat, schema de intrare.

findall

Built-in predicat findall(+Template, +Goal, -List) este utilizat pentru a colecta o lista List de toate elementele Template care indeplinesc un scop Goal. Exemplu: presupunem

likes(mary, pizza).
likes(marco, pizza).
likes(Human, pizza) :- italian(Human).
italian(marco).

Apoi

?- findall(Person, likes(Person, pizza), Bag).
Person = _G180
List = [mary, marco, marco]

findall reuseste si se leaga List la lista de gol, daca Goal nu are solutii. Acest lucru poate fi convenabil daca nu doriti ca scopul tau de a nu doar din cauza de colectare de solutii este gol. (In alte cazuri, ce-ar vrea scopul de a esua in cazul in care nu exista solutii.)

O alta diferenta intre bagof si findall este gradul de revenire inainte de a face obligatorii al treilea parametru ( List ). De exemplu, sa presupunem:

believes(john, likes(mary, pizza)).
believes(frank, likes(mary, fish)).
believes(john, likes(mary, apples)).

Apoi bagof si findall prezinta urmatorul comportament:

?- bagof(likes(mary, X), believes(_, likes(mary, X)), Bag).
X = _G188
Bag = [likes(mary, fish)] ;

X = _G188
Bag = [likes(mary, pizza), likes(mary, apples)] ;
false.

?- findall(likes(mary, X), believes(_, likes(mary, X)), Bag).
X = _G181
Bag = [likes(mary, pizza), likes(mary, fish), likes(mary, apples)] ;
false.

Puteti vedea ca bagof este colectarea de frank "convingerile lui despre ceea ce mary likes, cu caracter obligatoriu Bag, apoi backtracking si de percepere john "convingerile lui si re-legare a Bag, in timp ce findall gaseste toate credintele fiecaruia si leaga-le pe toate la Bag, doar o singura data.

A se vedea, de asemenea, setof.

fisiere, tell, telling, told, see, seeing, seen, append/1

Atunci cand se scrie un program Prolog, de obicei, faptele si regulile programului sunt stocate intr-un fisier (text), si apoi incarcate in interpretului Prolog. Fisierele au alte utilizari in Prolog, de asemenea.

De exemplu, am putea dori sa scrie un tabel de rezultate, care au fost calculate pentru noi prin programul nostru de Prolog. Se poate utiliza built-in predicate ca write, nl, putc, tab si pe altii sa scrie tabelul, dar in mod implicit acesta va aparea pe ecranul computerului. Pentru a directiona aceasta de iesire la un fisier, vom folosi tell built-in predicat. Sa presupunem ca dorim sa scrie tabelul intr-un fisier numit "mytable.data". De executare obiectivul (pseudo-) tell("mytable.data"), ne spune ca Prolog fluxul de noul curent de iesire trebuie sa fie fisierul "mytable.data". Ulterioare scrie va merge la acest fisier. Cand cineva doreste sa ma opresc din scris la dosar si a relua scris pe ecran, se foloseste predicat built-in told (cu nici un argument). De asemenea, interogarea ?- telling(X). se leaga X la numele fisierului curent de iesire. In cazul in care fluxul de curent de iesire nu este un fisier, atunci X va fi obligat la ceva care indica faptul ca fluxul de curent de iesire este pe ecran - de exemplu, in Unix, X poate fi legat de atom stdout (iesirea standard, care este in mod normal ecranului). Exemplu:

?- tell('mytable.data'), write('***** Table of results *****'), nl, told.
% the file mytable.data should now contain a single line of text as above

Built-in predicat Prolog append/1 este ca si cum tell, cu exceptia faptului ca se ocupa de operatiunile ulterioare a scrie pentru a adauga date la sfarsitul fisierului specificat, decat sa suprascrieti fisierul cu prima operatiune a scrie ulterioare. Daca myothertable.data initial contine, sa zicem, un singur rand, This is the first line, apoi append/1 functioneaza dupa cum urmeaza:

?- append('myotherfile.dat'), write('Here is another line'), nl.
true.
?- halt.
% cat myotherfile.dat # - # is Unix comment char, cat lists file contents
This is the first line
Here is another line
%

Situatia de lectura dintr-un fisier este analog de??a scrie (cu exceptia faptului ca nu exista nici un analog pentru append/1 ). Se poate utiliza built-in predicate cum ar fi read, getc si altii sa citeasca, in mod implicit de la tastatura. De executare obiectivul (pseudo-) see('mydata.text'), ne spune ca Prolog fluxul de intrare curent este nou sa fie fisierul mydata.text. Citeste ulterioare vor veni din acest fisier. Atunci cand se doreste pentru a opri citirea din dosar si a relua citirea de la tastatura, se foloseste predicat built-in seen (cu nici un argument). De asemenea, interogarea ?- seeing(X). se leaga X la numele fisierului de intrare curent. In cazul in care fluxul de intrare curent nu este un fisier, atunci X va fi obligat la ceva care indica faptul ca fluxul de curent de iesire este pe ecran - de exemplu, in Unix, X poate fi legat de atom stdin (intrarea standard, care este in mod normal tastatura). Exemplu:

?- see('mydata.text'), read(X), seen, write(X), nl.
% the first Prolog term in the file mydata.text should now appear
% on the screen, having been read from the file with read(X), and then
% written to the screen with write(X) and nl.

Ce se intampla daca incercati sa cititi dintr-un fisier si nu exista nimic (stanga) pentru a citi, fie din cauza ca fisierul este gol, sau ati citit anterior, tot ce era de citit in acest fisier? In acest caz, Prolog se leaga variabila care a fost argumentul de a read la atom speciale end_of_file. Stiind acest lucru inseamna ca puteti testa dupa o read pentru a va asigura ca nu ati lovit sfarsitul fisierului. Exemplu:

?- see('empty.dat'), read(Term).
Term = end_of_file 

A se vedea, de asemenea, fluxul de intrare curent, fluxul de iesire curent, intrare, iesire. append / 3 nu este legata de append/1.

functor, functor

In Prolog, functorul cuvantul este folosit cu referire la atom la inceputul unei structuri. De exemplu, in likes(mary, pizza), likes este functor. Intr-o structura mai complexa, cum ar fi

persondata(name(smith, john), date(28, feb, 1963))

functorul de nivel superior este numit functor principal - in acest caz persondata - Exista de asemenea un built-in predicat numit functor, folosit pentru a extrage functorul si aritatea a unei structuri.

Exista, de asemenea un built-in predicat functor cu trei argumente: functor(Term, Functor, Arity), care reuseste daca Term este un termen cu functor Functor si aritatea Arity. Exemple:

?- functor(likes(mary, pizza), Functor, Arity).
Functor = likes
Arity = 2 

?- functor(likes(X, Y), Functor, Arity).
X = _G180
Y = _G181
Functor = likes
Arity = 2

?- functor(likes, Functor, Arity).
Functor = likes
Arity = 0 

?- functor(X, likes, 2).
X = likes(_G232, _G233) 

Uneori, exista motive sa doreasca sa aiba functorul undeva, altele decat la inceputul structurii. De exemplu, in expresia X < Y, " < "este un functor:

?- functor(2 < 4, Functor, Arity).
Functor = (<),
Arity = 2.

?- 2 < 4.
true.

?- <(2, 4).
true.

A se vedea op pentru a afla cum functioneaza.

Functor termen este folosit intr-un sens diferit in matematica si in programare functional, si un alt mod din nou in filozofie.

scop

O interogare de interpret Prolog consta din unul sau mai multe goluri. De exemplu, in

?- lectures(john, Subject), studies(Student, Subject).

Exista doua goluri, lectures(john, Subject) si studies(Student, Subject). Un obiectiv este ceva care Prolog incearca sa satisfaca prin gasirea valori ale variabilelor (in acest caz, Student si Subject ), care fac obiectivul reusi. Aceste valoare (e) sunt apoi sa fie legat la variabila (e). Daca Prolog nu este in masura sa faca acest lucru, obiectivul nu reuseste (si Prolog va imprima "false", ca raspuns la interogare). Daca toate obiectivele dintr-o interogare reusi, Prolog imprima legaturile necesare pentru a face interogare de succes. (Daca atunci, in SWI Prolog, tastati un punct si virgula ( ; Prolog) va reiau ideea si sa caute un alt set de legaturi, care vor satisface obiectivele in interogare.

Uneori nu este necesar pentru a lega variabile, in scopul de a satisface un scop. De exemplu, nu exista nici o variabila de a lega, atunci cand scopul este likes(mary, pizza) si baza de date Prolog contine deja likes(mary, pizza). In acest caz, Prolog va imprima "true", ca raspuns la interogare, mai degraba decat legaturi de imprimare.

Gol apar in normele, precum si in interogari. In

happy(Dog) :-
    is_dog(Dog),
    go_for_walk(Dog).

is_dog(Dog) si go_for_walk(Dog) sunt cele doua obiective care formeaza corpul regulii.

% prolog
--- Welcome message from Prolog interpreter ---

?- halt.
%

sister_of(X,Y) :- female(Y), X \== Y, same_parents(X,Y).

date(21, mar, 2004)

persondata(name(smith, john), date(28, feb, 1963))

termen

Sintactic, toate obiectele de date din Prolog sunt termeni. De exemplu, atomul mar si date, precum si structura date(2004, mar, 21) sunt termeni. Deci, sunt numerele 2004 si 21, pentru care conteaza. Astfel, in date(2004, mar, 21), functorul primar este date, aritate este 3, iar argumentele sunt 2004, mar, si 21.

In general, un termen de aritate n poate fi un atom ( functorul ), urmate de argumente n, care vor fi incluse in paranteze ( ) si separate prin virgule. Retineti ca aritate ar putea fi 0, caz in care nu exista paranteze, virgule, sau argumente. Un termen poate fi, de asemenea, un numar. Uneori, termenul poate utiliza un infix operator ca <, caz in care functorului apare intre argumentele (daca este aritatea 2) sau inainte de argument, dar fara paranteze (daca aritatea este 1).

Pentru + si – (si ocazional ? semne), in fata argumentelor, in comentarii antet procedurii, a se vedea comentariile.

de testare de tip termen, atom, atomic, compound, float, integer, nonvar, number, var

Ar putea fi utila pentru a putea testa daca un termen este un numar sau o variabila sau altceva. Prolog ofera mai multe teste, cum ar:

Scop	reuseste daca X este...
var(X)	uninstantiated o variabila
nonvar(X)	nu o variabila, sau este o variabila instantiat
compound(X)	un termen compus - nu o variabila nelegata, si nu atomic (vezi mai jos)
atom(X)	un atom, sau legat la un atom
integer(X)	un intreg, sau legat de un intreg
float(X)	o virgula mobila (fractionare) numarul, cum ar fi de 3,5 sau 1.0, sau legat de o - dar, daca float(X) este evaluata cu ajutorul is, atunci veti primi aceasta float
number(X)	un numar, sau legat de un numar (intreg sau float)
atomic(X)	un numar, sir, sau atom, sau legat de o

de testare codul

Iata cateva sfaturi pentru testarea codul Prolog.
Si aici sunt cateva sfaturi pe scris, procedurile recursive in Prolog care includ unele sfaturi pentru depanare (in exemplul 3).

urmarirea

Tracing de executare a unei interogari Prolog va permite sa vedeti toate obiectivele pe care sunt executate ca parte a interogarii, in ordine, impreuna cu sau nu reusesc. De urmarire, de asemenea, va permite sa vedeti ce masuri sa apara ca backtracks Prolog.

Pentru a activa urmarirea in Prolog, executa "gol"

?- trace.

true.

Cand ati terminat cu urmarirea, opriti-l folosind "gol"

?- notrace.

Aici este un exemplu de trace in actiune. In primul rand un cod, care calculeaza N factorial - produsul dintre numerele de la 1 la N. Prin conventie, 0 factorial este 1. N factorial este scris de multe ori N!, in cazul in care un semn de exclamare semnifica "operator de factorial". Aici este codul:

factorial(0, 1). factorial(N, NFact) :- N > 0, Nminus1 is N - 1, factorial(Nminus1, Nminus1Fact), NFact is Nminus1Fact * N.

rule 1 rule 2 rule 2, goal 1 rule 2, goal 2 rule 2, goal 3 rule 2, goal 4

factorial(0) = 1 if N > 0, then compute N - 1, recursively work out factorial(N-1), then multiply that by N

Tabelele de mai sus si mai jos nu pot afisa corect daca vizualizate intr-o fereastra ingusta. In cazul in care comentariul nu pare sa se alinieze corect cu textul la stanga de ea, incearca sa faci fereastra browser-ului mai mare.

Prolog de??dialog / urme de iesire

Comentariu

prolog -s factorial.pl blah blah blah … ?- trace. true. [trace] ?- factorial(3, X). Call: (7) factorial(3, _G284) ? creep* ^ Call: (8) 3>0 ? creep ^ Exit: (8) 3>0 ? creep ^ Call: (8) _L205 is 3-1 ? creep ^ Exit: (8) 2 is 3-1 ? creep Call: (8) factorial(2, _L206) ? creep ^ Call: (9) 2>0 ? creep ^ Exit: (9) 2>0 ? creep ^ Call: (9) _L224 is 2-1 ? creep ^ Exit: (9) 1 is 2-1 ? creep Call: (9) factorial(1, _L225) ? creep ^ Call: (10) 1>0 ? creep ^ Exit: (10) 1>0 ? creep ^ Call: (10) _L243 is 1-1 ? creep ^ Exit: (10) 0 is 1-1 ? creep Call: (10) factorial(0, _L244) ? creep Exit: (10) factorial(0, 1) ? creep ^ Call: (10) _L225 is 1*1 ? creep ^ Exit: (10) 1 is 1*1 ? creep Exit: (9) factorial(1, 1) ? creep ^ Call: (9) _L206 is 1*2 ? creep ^ Exit: (9) 2 is 1*2 ? creep Exit: (8) factorial(2, 2) ? creep ^ Call: (8) _G284 is 2*3 ? creep ^ Exit: (8) 6 is 2*3 ? creep Exit: (7) factorial(3, 6) ? creep X = 6 ; Redo: (10) factorial(0, _L244) ? creep ^ Call: (11) 0>0 ? creep ^ Fail: (11) 0>0 ? creep Fail: (9) factorial(1, _L225) ? creep Fail: (8) factorial(2, _L206) ? creep Fail: (7) factorial(3, _G284) ? creep false. [debug] ?- notrace. % turn off tracing true. [debug] ?-

Invoke prolog, loading code for factorial Greeting from Prolog Turn on tracing Call factorial Trace echoes query, replacing X with a unique variable Rule 2, Goal 1 (N > 0) is invoked Goal 1 succeeds immediately Rule 2, Goal 2 invoked to compute 3 - 1 and succeeds Rule 2, Goal 3 is invoked: level 2 call to factorial(2, …) Goal 1 again for new call to factorial Goal 1 succeeds New version of goal 2 succeeds Rule 2, Goal 3 is invoked: level 3 call to factorial(1, …) Goal 1 again succeeds Goal 2 again successfully Rule 2, Goal 3 is invoked: recursive call to factorial(0, …) This time, Rule 1 succeeds at once. This is Goal 4 of level 3 Compute 1 * 1 without trouble so the level 3 factorial call succeeds This is goal 4 of level 2 Compute 1 * 2 without trouble so the level 2 factorial call succeeds This is goal 4 of level 1 Compute 2 * 3 without trouble so the level 1 factorial call succeeds … with this binding of X - type ";" to find more solutions Prolog backtracks looking for another solution without success Turn off tracing.

* Ce este aceasta "creep" de afaceri? In SWI Prolog, punerea in aplicare a acestui dictionar Prolog care utilizeaza pentru sintaxa de exemple sale, atunci cand apasati reveni la sfarsitul unei linii de urmarire, Prolog printuri "creep", pe aceeasi linie, si apoi imprima urmatoarea linie de urme de iesire de pe linia urmatoare. Apasand intoarcere produce din nou "creep" din nou si o alta linie de urmarire, si asa mai departe.

Exista alte facilitati de urmarire in SWI Prolog. Face

?- help(trace).

pentru a incepe pentru a afla despre ele.

Built-in functii Prolog nu sunt trasate - care este, interne de apeluri la lucruri ca member nu sunt explicate in detaliu de catre urmarirea lor.

true

Built-in predicat Prolog fara nici un argument, care, dupa cum sugereaza si numele, reuseste intotdeauna.

A se vedea, de asemenea, fail, repeat.

A se vedea articolul pe care nu le pasa variabile.

subliniere, tacerea: nu-ingrijire variabila

Variabila Prolog _ (subliniere) este un "tacerea: nu-ingrijire" variabila, care se va potrivi nimic (atom, numarul, structura,...). De exemplu, regula

bad(Dog) :- bites(Dog, _).

spune ca ceva ( Dog ) este rau in cazul in care Dog musca ceva. "Ceva" este reprezentat de _. Spre deosebire de alte variabile in Prolog, un gol _ poate meci de lucruri diferite in aceeasi regula. Deci, de exemplu, in cazul in care gives(From, To, Gift) este o procedura de trei loc care este valabil in cazul in care From da Gift la To, atunci

giver(X) :- gives(X, _, _).

semnifica faptul ca cineva ( X ) este un "datator" daca X da ceva la cineva - cele doua _ e nu trebuie sa se potriveasca acelasi lucru. Deci, daca gives(fred, john, black_eye). sunt stocate in baza de date Prolog, apoi regula de mai sus ne permite sa se deduca faptul ca fred este un datator.

Pentru a fi mai explicit cu privire la sensul de regula, ai putea scrie in schimb:

bad(Dog) :- bites(Dog, _Anybody).

Acest lucru indica ceea ce _ variabila este de fapt reprezinta, dar are caracteristica ca legarea de _Anybody de obicei, nu se raporteaza atunci cand Prolog gaseste o solutie. In acest raport interpreti Prolog variabilele Singleton (variabile care sunt utilizate numai o data intr-o regula - de multe ori acestea sunt cauzate de erorile tipografice in cod, care este motivul pentru care Prolog va avertizeaza despre ele) nu raporteaza variabile Singleton care incep cu _. Acest lucru este util este pe care incercati sa scape de mesaje de avertizare in codul Prolog dumneavoastra.

Regula

bad(Dog) :- bites(Dog, _Anybody).

de fapt, are un bug, in sensul ca se va potrivi _Anybody lucruri (cum ar fi dogfood) ca un caine ar putea sa muste, fara a fi "rau". Poate ca regula ar trebui sa spun in schimb:

bad(Dog) :-
    bites(Dog, Something),
    is_person(Something).
% add your own list of prohibitions - shoes, cats, …

Sisteme Prolog face uz intern de nume de variabile care incep cu o linie de subliniere, de exemplu, _G157. Acestea nu sunt "tacerea: nu-ingrijire", variabile, dar sunt alese nu sa intre in conflict cu orice nume de variabila de un programator Prolog este probabil de a utiliza.

Subliniaza, de asemenea, pot fi utilizate in mijlocul de nume de variabile sau atom, la fel ca in Intermediate_solution, likes_person - din nou, acestea nu sunt "tacerea: nu-ingrijire" variabile. Ideea este de a face un nume de variabila sau atom mai usor de citit.

unificare, =, \=

Cand ne-am scrie un gol ca X = Y in Prolog, suntem de testare pentru mai mult de egalitate simpla, in sensul matematic. Suntem de testare, daca X (care ar putea fi o variabila, un atom, sau un complex arbitrar termen lung ) se unifica cu Y (care ar putea fi, de asemenea, un atom, o variabila, sau un termen). Doi atomi, atomii inclusiv numerice, unifica in cazul in care sunt aceleasi. Doi termeni mai complexe unifica daca au aceleasi functorul si corespunzatoare acestora argumente unifica. O variabila intotdeauna se unifica cu un termen (cu conditia ca nu este in prealabil unificat cu ceva diferit), prin legare la termen Exemple.:

?- fred = fred. true.	fred se unifica cu fred - acestea sunt acelasi atom.
?- X = fred. X = fred	X se unifica cu fred prin legarea de X la fred.
?- X = likes(mary, pizza). X = likes(mary, pizza).	X se unifica cu likes(mary, pizza) by binding X to likes(mary, pizza).
?- likes( | mary, | book( | title(Title), | author( | given('Herman'), | SurnameTerm))) | = | likes( | Who, | book( | title('Moby Dick'), | author( | given('Herman'), | surname('Melville')))). Title = 'Moby Dick', SurnameTerm = surname('Melville'), Who = mary.	Retineti ca | caractere de la inceputul fiecarei linii sunt continuarea solicita de la Prolog, deoarece aceasta interogare a fost raspandit peste mai mult de o linie. Title, SurnameTerm, si Who sunt obligate, in scopul de a realiza unificarea. Functori primar al termenilor pe fiecare parte a = meci, si veniturile unificarea prin potrivirea de perechi de argumente corespunzatoare, de exemplu, prin potrivirea si unificarea primul argument pe stanga, mary, cu primul argument pe dreapta, Who. Unificarea reuseste daca toate argumentele meci. Acest lucru va include recursiv potrivite argumente ale substructurilor, cum ar fi author/2 substructuri.

Scopul X \= Y reuseste daca X = Y nu ar reusi, aceasta este forma de negat =.

Utilizarea inutila a " =" la Forta Unirii

Aceasta este de fapt o problema de stil. Luati in considerare urmatoarele doua bucati alternative de cod Prolog pentru calcul maxim doua numere.

max1(X, Y, X) :- X > Y.
max1(X, Y, Y) :- X =< Y.

contra

max2(X, Y, Max) :- X > Y, Max = X.
max2(X, Y, Max) :- X =< Y, Max = Y.

Prima versiune este de preferat, in special pentru un programator novice Prolog, deoarece consolideaza modul in care functioneaza Prolog. De asemenea, nu implica inutile Max = X sau Max = Y.

Ori de cate ori scrii " = "intr-o procedura de Prolog, a revedea codul pentru a vedea daca poate scapa de" = "clauza prin inlocuirea articol de pe stanga a" = "prin elementul de la dreptul de ea, in alta parte in procedura. Daca veti face acest lucru cu max2, te max1. Uneori este posibil sa fi scris " = "cu variabila de pe dreapta, caz in care aveti nevoie pentru a inlocui in loc de articol de pe partea dreapta a" = "cu elementul la stanga de ea.

Ar trebui sa fie posibil sa facem acest lucru ori de cate ori exista o variabila (mai degraba decat o mai complex termen ), pe cel putin o parte a " = ".

Univ, =..

=.. meta-predicat, pronuntat "Univ", poate fi folosit pentru a converti o lista a caror prima post este un atom non-numerice, intr-un termen, si vice-versa. =.. De exemplu,

?- Term =.. [likes, mary, pizza].
Term = likes(mary, pizza).

sau

?- likes(mary, pizza) =.. List.
List = [likes, mary, pizza].

univ functioneaza cu operatori infix, de asemenea, desi probabil intr-un mod usor neasteptat. Doua exemple:

?- op(700, xfy, and).

true.

?- Term =.. [and, p, q].

Term = p and q

?- Expression =.. [+, 2, 3], Value is Expression.

Expression = 2+3
Value = 5

variabil

O variabila in Prolog este un sir de litere, cifre, si de subliniere ( _ ), incepand fie cu o scrisoare de capital sau cu o liniuta de subliniere. Exemple: X, Sister, _, _thing, _y47, First_name, Z2 Variabila _ este folosit ca un "tacerea: nu-ingrijire" variabila, atunci cand nu ne minte ce valoare are variabila. De exemplu:

is_a_parent(X) :- father_of(X, _).
is_a_parent(X) :- mother_of(X, _).

Asta este, X este un parinte in cazul in care sunt un tata sau o mama, dar nu avem nevoie sa stie cine sunt tatal sau mama, pentru a stabili ca acestea sunt un parinte.

Variabilele sunt folosite in mai mult de un fel:

• sa-si exprime constrangeri in anumite parti ale unei reguli:
  likes(A,B) :- dog(B), feeds(A,B).
  Retineti ca atat A si B apar pe ambele parti ale gatului simbol - aspectul de aceeasi variabila in doua (sau mai multe locuri) in vigoare spune ca, atunci cand variabila este legat la o valoare, aceasta trebuie sa fie legate la aceeasi valoare in toate locurile pe care acesta apare intr-o regula data.
  Retineti ca, in cazul in care aceeasi variabila apare in doua sau mai multe reguli diferite, ar putea fi obligat la valori diferite in reguli diferite. Acest lucru este realizat prin redenumirea Prolog variabilele intern, atunci cand este vorba de a utiliza regula - de obicei, numele sunt lucruri cum ar fi _1, _2, _3, etc Acesta este motivul pentru variabile cu nume ca aceste randul sau, uneori pana in mesaje de eroare atunci cand programul Prolog merge prost.

• sa formuleze intrebari, ca in urmatorul exemplu:
  ?- studies(X, 9311). Prolog raspunde prin gasirea toate valorile pentru X pentru care studies(X, 9311) este adevarat, si le listarea succesiv, de exemplu,

  X = fred ;
  X = jane ;
  X = abdul ;
  X = maria ;

spatiu alb

In scris cod in Prolog sau orice alt limbaj de programare, spatiu alb (linii goale, indentarea, alinierea poate de articole legate de date) poate fi folosit pentru a face codul mai usor de urmarit. Iata cateva sugestii:

• Pune o linie goala inainte de inceperea oricarei prolog procedura.
• Colectii grup de fapte utilizand linii goale.
• Uneori ajuta la linia de pana comentarii, dar nu in detrimentul de a face linii de mai mult de aproximativ 75-80 de caractere.
• Nu puneti procedurile ajutor in mijlocul altor proceduri: separa-le inainte sau dupa procedura pe care o ajuta. In cazul in care procedura de ajutor este utilizat in procedurile de mai multe alte, este posibil sa doriti sa-l puneti chiar la capatul de toate cod.

Exemplu. In ferestrele browser-ului dimensiune moderata, exemplu negativ va avea linii de mult timp, care sunt indoite de browser-ul, si bun exemplu nu vor. In practica, ai putea face liniile din exemplul de bun, mai degraba mai mult - pana la 75-80 de caractere.

Bine

Rau

% smallest(+ListOfNumbers, -Min) % binds Min to the smallest item % in the non-empty ListOfNumbers. % ListOfNumbers should be instantiated % at time of call. smallest([FirstNum], FirstNum). smallest([FirstNum | Rest], Min) :- smallest(Rest, MinRest), smaller(FirstNum, MinRest, Min). % smaller(+First, +Second, -Smaller) % helper procedure for smallest. smaller(A, B, A) :- A <= B. smaller(A, B, B) :- B < A.

% smallest(ListOfNumbers, Min) binds Min to the smallest item in the non-empty ListOfNumbers. ListOfNumbers should be instantiated at time of call. smaller(A, B, A) :- A <= B. smaller(A, B, B) :- B < A. % This is a helper procedure for smallest. smallest([FirstNum], FirstNum). smallest([FirstNum | Rest], Min) :- smallest(Rest, MinRest), smaller(FirstNum, MinRest, Min).

A se vedea, de asemenea, indentarea si comentarii.