Het gebruik van de ingebouwde predicaten, de volgorde van doelen, of het specificeren van een doel bij de systeemprompt, zou op zichzelf weinig waarde hebben. Om een ​​Prolog-programma te schrijven, moet de gebruiker eerst een programma schrijven dat in de Prolog-taal is geschreven, dat programma laden en vervolgens een reeks van een of meer doelen opgeven bij de prompt.

Om een ​​programma in Prolog te maken, is de eenvoudige manier om het in de teksteditor te typen en het vervolgens op te slaan als een tekstbestand zoals prolog1.pl .

Het volgende voorbeeld toont een eenvoudig programma van Prolog. Het programma bevat drie componenten, die bekend staan ​​als clausules. Elke clausule wordt afgesloten met een punt.

 dog(rottweiler). cat(munchkin). animal(A) :- cat(A). 

Het ingebouwde predikaat gebruiken ' raadplegen' , kan het bovenstaande programma in het Prolog-systeem worden geladen.

?-consult('prolog1.pl').

Dit toont aan dat het bestand prolog1.pl bestaat en dat het prolog-programma systemisch correct is, wat betekent dat het geldige clausules heeft. Het doel zal slagen en om te bevestigen dat het programma correct is gelezen, produceert het een of meer regels uitvoer. bijvoorbeeld

?-
# 0,00 seconden om prolog1.pl te raadplegen
?-

k dichtstbijzijnde buuralgoritme

Het alternatief voor 'consult' is 'Load', dat aanwezig zal zijn in de menuoptie als het Prolog-systeem een ​​grafische gebruikersinterface heeft.

Wanneer het programma wordt geladen, wordt de clausule in een opslaggebied geplaatst, en dat opslaggebied staat bekend als de Prolog-database. Als reactie op de systeemprompt geeft u een reeks doelen op, waarna Prolog de clausules zoekt en gebruikt die nodig zijn om de doelen te evalueren.

Terminologie

In het volgende programma tonen drie regels de clausules.

 dog(rottweiler). cat(munchkin). animal(A) :- cat(A). 

Met behulp van de punt wordt elke clausule beëindigd. Prolog-programma's hebben een reeks clausules. Feiten of regels worden door deze clausules beschreven.

Voorbeeld van feiten is hond (rottweiler) En kat (munchkin) . Ze bedoelen dat ' Rottweiler is een hond' en ' munchkin is een kat'.

Hond wordt een predikaat genoemd. Hond bevat één argument. Woord ' rottweiler' tussen haakjes ( ). Rottweiler wordt een atoom genoemd.

Het voorbeeld van een regel is de laatste regel van het programma.

 animal(A) :- dog(A). 

Het dubbelepunt(:-)-teken wordt gelezen als 'if'. Hier is A een variabele en vertegenwoordigt elke waarde. Op een natuurlijke manier kan de regel worden gelezen als 'Als A een dier is, dan is A een hond'.

Uit bovenstaande clausule blijkt dat de Rottweiler is een dier. Een dergelijke aftrek kan Prolog ook maken:

?- dier(rottweiler).
Ja

Om dat te impliceren munchkin is een dier, daar is geen bewijs voor.

?- dier(munchkin).
Nee

Meer terminologie

Het evalueren van een doelterm bepaalt of er al dan niet aan wordt voldaan. Het betekent ook dat het doel wordt geëvalueerd als waar of onwaar.

Houd er rekening mee dat wanneer een gebruiker een doel invoert, dit soms kan worden geïnterpreteerd als een commando. Bijvoorbeeld,

?- stop. 'Het wordt gebruikt om het Prolog-systeem te verlaten.'

Soms kan het worden beschouwd als een vraag als:

?- dier(rottweiler). & 'Is rottweiler een dier?'

Het volgende programma toont nog een voorbeeld over dieren. Het bestaat uit acht clausules. Het commentaar wordt weergegeven door alle tekst tussen /* en */.

 /* Another Program of Animal */ Dog(rottweiler). cat(sphynx). dog(poodle). dog(bulldog). cat(bengal). dog(dobermann). cat(himalayan). cat(singapura). /* This Prolog program consists of various clauses. It is always terminated using the full stop.*/ 

Predicaat hond en predikaat kat hebben beide vier clausules. Stel dat het programma in een tekstbestand 'animal.pl' is opgeslagen en dat uitvoer wordt gegenereerd door het laden van het programma en dat we bij de systeemprompt een reeks doelen als volgt invoeren:

?- raadplegen('dieren1.pl'). Systeemprompt
# 0,01 seconden om dieren.pl te raadplegen dieren.pl geladen met behulp van de consultatie

?- hond(rottweiler).
Ja

?- hond (bokser).
Nee

?- hond(A).
A = rottweiler pauzeert - de return-toets wordt door de gebruiker ingedrukt

?- hond(B).
B = rottweiler; pauzeert? gebruiker drukt op ;
B = poedel; pauzeert? gebruiker drukt op ;
B = buldog; pauzeert? gebruiker drukt op ;
B = dobermann Geen pauze? Het gaat naar de volgende regel

?- kat(A). A = sfinx; pauzeren? gebruiker drukt;
A = Bengalen pauzeert? gebruiker drukt op return

?- luisteren(hond). Het zal alle clausules vermelden die het predicaat hond definiëren

/* hond/1 */

hond (rottweiler).
hond (poedel).
hond (bulldog).
hond (doberman).
Ja
?-

In dit voorbeeld worden verschillende nieuwe functies van Prolog geïntroduceerd. De vraag is als volgt:

?- hond(A).

Het betekent dat je de waarde van de A moet vinden, en het zal de naam van de hond zijn. Het antwoord van Prolog is als volgt:

A = rottweiler

Andere mogelijke antwoorden van A zijn als volgt: poedel, bulldog, dobermann. Het zal de Prolog-pauze veroorzaken, en daarom moeten we wachten tot de gebruiker op de 'return'-toets drukt voordat de systeemprompt ?- wordt weergegeven.

We kunnen de volgende vraag als volgt invoeren:

?- hond(B).

Deze vraag is dezelfde als voorheen. De bovenstaande vraag betekent: 'vind de waarde van de B, en het zal de naam van een hond zijn'. Het antwoord van Prolog is als volgt:

B = rottweiler

java hoe te overschrijven

Prolog zal opnieuw pauzeren. Deze keer wordt de puntkomma-toets (;) door de gebruiker ingedrukt. Nu zal Prolog een alternatieve waarde van B vinden die voldoet aan de doelhond (B). Het zal als volgt antwoorden:

B = poedel

Prolog zal opnieuw pauzeren. De puntkomma-toets (;) wordt opnieuw door de gebruiker ingedrukt. Prolog komt als volgt met een verdere oplossing:

B = buldog

Prolog zal opnieuw pauzeren. De puntkomma-toets (;) wordt opnieuw door de gebruiker ingedrukt. Prolog komt als volgt met een verdere oplossing:

B = dobermann

Prolog erkent dat er geen oplossing meer beschikbaar is door niet te pauzeren, maar de systeemprompt? - door onmiddellijk door te gaan naar de uitvoer.

In dit voorbeeld wordt een nieuw ingebouwd predikaat geïntroduceerd. Het specificeren van het doel

?- vermelding(hond)

In het bovenstaande doel zal Prolog alle vier de clausules opsommen die het predicaat hond definiëren. Ze definiëren in dezelfde volgorde als waarin ze in de database zijn geladen.

Het gebruik van variabelen in de query wordt weergegeven in het volgende voorbeeld. De volgorde van de doelen is als volgt:

?-kat(A),hond(B).

java mvc

Dit geeft ons alle mogelijke combinaties van een kat en een hond.

?-kat(A),hond(B).
A = sfinx,
B = rottweiler;

A = sfinx,
B = poedel;

A = sfinx,
B = buldog;

A = sfinx,
B = dobermann;

enz.

De volgorde van de doelen is daarentegen als volgt:

?-kat(A), hond(A).

Dit geeft alle dieren die zowel een kat als een hond zijn (in de database bestaat zo'n dier niet). Hier is A 'elke waarde' in zowel kat(A) als hond(A), maar beide moeten dezelfde waarde hebben.

?-kat(A),hond(A).
Nee